questa opzione ciascun capo della connessione annuncia all'altro il massimo
ammontare di dati che vorrebbe accettare per ciascun segmento nella
connessione corrente. È possibile leggere e scrivere questo valore
- attraverso l'opzione del socket \macro{TCP\_MAXSEG}.
+ attraverso l'opzione del socket \const{TCP\_MAXSEG}.
\item \textit{window scale option}; come spiegato in \capref{cha:tcp_protocol}
il protocollo TCP implementa il controllo di flusso attraverso una
posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
associati alle interfacce locali; la notazione 0.0.0.0 usata da netstat è
equivalente all'asterisco utilizzato per il numero di porta ed indica il
-valore generico, e corrisponde al valore \macro{INADDR\_ANY} definito in
+valore generico, e corrisponde al valore \const{INADDR\_ANY} definito in
\file{arpa/inet.h}.
Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
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.
- \item[\macro{ENOTSOCK}] il file descriptor non è associato ad un socket.
- \item[\macro{EACCESS}] si è cercato di usare una porta riservata senza
- sufficienti privilegi.
+ \item[\errcode{EBADF}] il file descriptor non è valido.
+ \item[\errcode{EINVAL}] il socket ha già un indirizzo assegnato.
+ \item[\errcode{ENOTSOCK}] il file descriptor non è associato ad un socket.
+ \item[\errcode{EACCESS}] si è cercato di usare una porta riservata senza
+ sufficienti privilegi.
\end{errlist}}
\end{prototype}
client.
Per specificare un indirizzo generico con IPv4 si usa il valore
-\macro{INADDR\_ANY}, il cui valore, come visto anche negli esempi precedenti
+\const{INADDR\_ANY}, il cui valore, come visto anche negli esempi precedenti
è pari a zero, nell'esempio \figref{fig:net_serv_code} si è usata
un'assegnazione immediata del tipo:
\normalsize
Si noti che si è usato \func{htonl} per assegnare il valore
-\macro{INADDR\_ANY}; benché essendo questo pari a zero il riordinamento sia
-inutile; ma dato che tutte le costanti \macro{INADDR\_} sono definite
+\const{INADDR\_ANY}; benché essendo questo pari a zero il riordinamento sia
+inutile; ma dato che tutte le costanti \val{INADDR\_} sono definite
secondo l'ordinamento della macchina è buona norma usare sempre la funzione
-\macro{htonl}.
+\func{htonl}.
L'esempio precedete funziona con IPv4 dato che l'indirizzo è rappresentabile
anche con un intero a 32 bit; non si può usare lo stesso metodo con IPv6,
Per questo nell'header \file{netinet/in.h} è definita una variabile
\type{in6addr\_any} (dichiarata come \ctyp{extern}, ed inizializzata dal
-sistema al valore \macro{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
+sistema al valore \const{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
assegnazione del tipo:
\footnotesize
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
+ \item[\errcode{ECONNREFUSED}] non c'è nessuno in ascolto sull'indirizzo
+ remoto.
+ \item[\errcode{ETIMEDOUT}] si è avuto timeout durante il tentativo di
connessione.
- \item[\macro{ENETUNREACH}] la rete non è raggiungibile.
- \item[\macro{EINPROGRESS}] il socket è non bloccante (vedi
+ \item[\errcode{ENETUNREACH}] la rete non è raggiungibile.
+ \item[\errcode{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
+ \item[\errcode{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
+ \item[\errcode{EAGAIN}] non ci sono più porte locali libere.
+ \item[\errcode{EAFNOSUPPORT}] l'indirizzo non ha una famiglia di indirizzi
corretta nel relativo campo.
- \item[\macro{EACCESS, EPERM}] si è tentato di eseguire una connessione ad un
- indirizzo broadcast senza che il socket fosse stato abilitato per il
+ \item[\errcode{EACCESS, EPERM}] si è tentato di eseguire una connessione ad
+ un indirizzo broadcast senza che il socket fosse stato abilitato per il
broadcast.
\end{errlist}
- altri errori possibili sono: \macro{EFAULT}, \macro{EBADF},
- \macro{ENOTSOCK}, \macro{EISCONN} e \macro{EADDRINUSE}.}
+ altri errori possibili sono: \const{EFAULT}, \const{EBADF},
+ \const{ENOTSOCK}, \const{EISCONN} e \const{EADDRINUSE}.}
\end{prototype}
La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
seguenti:
\begin{enumerate}
\item Il client non riceve risposta al SYN: l'errore restituito è
- \macro{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
+ \errcode{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
di \func{connect}, un'altro dopo 6 secondi, un terzo dopo 24 secondi, se
dopo 75 secondi non ha ricevuto risposta viene ritornato l'errore. Linux
invece ripete l'emissione del SYN ad intervalli di 30 secondi per un numero
che vuol dire probabilmente che o si è sbagliato il numero della porta o che
non è stato avviato il server), questo è un errore fatale e la funzione
ritorna non appena il RST viene ricevuto riportando un errore
- \macro{ECONNREFUSED}.
+ \errcode{ECONNREFUSED}.
Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
essere dovuto ad una condizione transitoria si ripete l'emissione dei SYN
come nel caso precedente, fino al timeout, e solo allora si restituisce il
codice di errore dovuto al messaggio ICMP, che da luogo ad un
- \macro{ENETUNREACH}.
+ \errcode{ENETUNREACH}.
\end{enumerate}
La funzione pone il socket specificato da \var{sockfd} in modalità
passiva e predispone una coda per le connessioni in arrivo di lunghezza pari
a \var{backlog}. La funzione si può applicare solo a socket di tipo
- \macro{SOCK\_STREAM} o \macro{SOCK\_SEQPACKET}.
+ \const{SOCK\_STREAM} o \const{SOCK\_SEQPACKET}.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
errore. I codici di errore restituiti in \var{errno} sono i seguenti:
\begin{errlist}
- \item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
+ \item[\errcode{EBADF}] l'argomento \var{sockfd} non è un file descriptor
valido.
- \item[\macro{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
- \item[\macro{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
+ \item[\errcode{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
+ \item[\errcode{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
operazione.
\end{errlist}}
\end{prototype}
Il parametro \var{backlog} indica il numero massimo di connessioni pendenti
accettate; se esso viene ecceduto il client riceverà una errore di tipo
-\macro{ECONNREFUSED}, o se il protocollo, come nel caso del TCP, supporta la
+\errcode{ECONNREFUSED}, o se il protocollo, come nel caso del TCP, supporta la
ritrasmissione, la richiesta sarà ignorata in modo che la connessione possa
essere ritentata.
protezione dei syncookies però (con l'opzione da compilare nel kernel e da
attivare usando \file{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore
viene ignorato e non esiste più un valore massimo. In ogni caso in Linux il
-valore di \var{backlog} viene troncato ad un massimo di \macro{SOMAXCONN}
+valore di \var{backlog} viene troncato ad un massimo di \const{SOMAXCONN}
se è superiore a detta costante (che di default vale 128).
La scelta storica per il valore di questo parametro è di 5, e alcuni vecchi
\var{errno} viene impostata ai seguenti valori:
\begin{errlist}
- \item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
+ \item[\errcode{EBADF}] l'argomento \var{sockfd} non è un file descriptor
valido.
- \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 impostato come
- non bloccante (vedi \secref{sec:file_noblocking}), e non ci sono
+ \item[\errcode{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
+ \item[\errcode{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
+ operazione.
+ \item[\errcode{EAGAIN} o \errcode{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
+ \item[\errcode{EPERM}] Le regole del firewall non consentono la connessione.
+ \item[\errcode{ENOBUFS, ENOMEM}] questo spesso significa che l'allocazione
della memoria è limitata dai limiti sui buffer dei socket, non dalla
memoria di sistema.
\end{errlist}
Inoltre possono essere restituiti gli errori di rete relativi al nuovo
- socket come: \macro{EMFILE}, \macro{EINVAL}, \macro{ENOSR}, \macro{ENOBUFS},
- \macro{EFAULT}, \macro{EPERM}, \macro{ECONNABORTED},
- \macro{ESOCKTNOSUPPORT}, \macro{EPROTONOSUPPORT}, \macro{ETIMEDOUT},
- \macro{ERESTARTSYS}.}
+ socket come: \const{EMFILE}, \const{EINVAL}, \const{ENOSR}, \const{ENOBUFS},
+ \const{EFAULT}, \const{EPERM}, \const{ECONNABORTED},
+ \const{ESOCKTNOSUPPORT}, \const{EPROTONOSUPPORT}, \const{ETIMEDOUT},
+ \const{ERESTARTSYS}.}
\end{prototype}
La funzione può essere usata solo con socket che supportino la connessione
-(cioè di tipo \macro{SOCK\_STREAM}, \macro{SOCK\_SEQPACKET} o
-\macro{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
+(cioè di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET} o
+\const{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
esplicita della connessione, (attualmente in Linux solo DECnet ha questo
comportamento), la funzione opera solo l'estrazione dalla coda delle
connessioni, la conferma della connessione viene fatta implicitamente dalla
errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
\func{accept} passa gli errori di rete pendenti sul nuovo socket come codici
di errore per \func{accept}. Inoltre la funzione non fa ereditare ai nuovi
-socket flag come \macro{O\_NONBLOCK}, che devono essere rispecificati volta
+socket flag come \const{O\_NONBLOCK}, che devono essere rispecificati volta
volta, questo è un comportamento diverso rispetto a quanto accade con BSD e
deve essere tenuto in conto per scrivere programmi portabili.
cui indirizzo è passato come argomento in \var{cliaddr}, al ritorno della
funzione \var{addrlen} conterrà il numero di byte scritti dentro
\var{cliaddr}. Se questa informazione non interessa basterà inizializzare a
-\macro{NULL} detti puntatori.
+\val{NULL} detti puntatori.
Se la funzione ha successo restituisce il descrittore di un nuovo socket
creato dal kernel (detto \textit{connected socket}) a cui viene associata la
dalla funzione. Se non ci sono connessioni pendenti da accettare la funzione
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
+ ritorna con l'errore \errcode{EAGAIN}. Torneremo su questa modalità di
operazione in \secref{sec:xxx_sock_noblock}.} fintanto che non ne arriva
una.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
errore. I codici di errore restituiti in \var{errno} sono i seguenti:
\begin{errlist}
- \item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
+ \item[\errcode{EBADF}] l'argomento \var{sockfd} non è un file descriptor
valido.
- \item[\macro{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
- \item[\macro{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
+ \item[\errcode{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
+ \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
eseguire l'operazione.
- \item[\macro{EFAULT}] l'argomento \var{name} punta al di fuori dello
+ \item[\errcode{EFAULT}] l'argomento \var{name} punta al di fuori dello
spazio di indirizzi del processo.
\end{errlist}}
\end{prototype}
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
errore. I codici di errore restituiti in \var{errno} sono i seguenti:
\begin{errlist}
- \item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
+ \item[\errcode{EBADF}] l'argomento \var{sockfd} non è un file descriptor
valido.
- \item[\macro{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
- \item[\macro{ENOTCONN}] il socket non è connesso.
- \item[\macro{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
+ \item[\errcode{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
+ \item[\errcode{ENOTCONN}] il socket non è connesso.
+ \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
eseguire l'operazione.
- \item[\macro{EFAULT}] l'argomento \var{name} punta al di fuori dello
+ \item[\errcode{EFAULT}] l'argomento \var{name} punta al di fuori dello
spazio di indirizzi del processo.
\end{errlist}}
\end{prototype}
gestione dei file.
\begin{description}
-\item \macro{EPERM} \textit{Operation not permitted}. L'operazione non è
+\item \errcode{EPERM} \textit{Operation not permitted}. L'operazione non è
permessa: solo il proprietario del file o un processo con sufficienti
privilegi può eseguire l'operazione.
-\item \macro{ENOENT} \textit{No such file or directory}. Il file indicato dal
+\item \errcode{ENOENT} \textit{No such file or directory}. Il file indicato dal
pathname non esiste: o una delle componenti non esiste o il pathname
contiene un link simbolico spezzato. Errore tipico di un riferimento ad un
file che si suppone erroneamente essere esistente.
-\item \macro{EIO} \textit{Input/output error}. Errore di input/output: usato
+\item \errcode{EIO} \textit{Input/output error}. Errore di input/output: usato
per riportare errori hardware in lettura/scrittura su un dispositivo.
-\item \macro{ENXIO} \textit{No such device or address}. Device inesistente: il
+\item \errcode{ENXIO} \textit{No such device or address}. Device inesistente: il
sistema ha tentato di usare un dispositivo attraverso il file specificato,
ma non lo ha trovato. Può significare che il file di dispositivo non è
corretto, che il modulo relativo non è stato caricato nel kernel, o che il
dispositivo è fisicamente assente o non funzionante.
-\item \macro{ENOEXEC} \textit{Invalid executable file format}. Il file non ha
+\item \errcode{ENOEXEC} \textit{Invalid executable file format}. Il file non ha
un formato eseguibile, è un errore riscontrato dalle funzioni \func{exec}.
-\item \macro{EBADF} \textit{Bad file descriptor}. File descriptor non valido:
+\item \errcode{EBADF} \textit{Bad file descriptor}. File descriptor non valido:
si è usato un file descriptor inesistente, o aperto in sola lettura per
scrivere, o viceversa, o si è cercato di eseguire un'operazione non
consentita per quel tipo di file descriptor.
-\item \macro{EACCESS} \textit{Permission denied}. Permesso negato; l'accesso
+\item \errcode{EACCESS} \textit{Permission denied}. Permesso negato; l'accesso
al file non è consentito: i permessi del file o della directory non
consentono l'operazione.
-\item \macro{ELOOP} \textit{Too many symbolic links encountered}. Ci sono
+\item \errcode{ELOOP} \textit{Too many symbolic links encountered}. Ci sono
troppi link simbolici nella risoluzione di un pathname.
-\item \macro{ENAMETOOLONG} \textit{File name too long}. Si è indicato un
+\item \errcode{ENAMETOOLONG} \textit{File name too long}. Si è indicato un
pathname troppo lungo.
-\item \macro{ENOTBLK} \textit{Block device required}. Si è specificato un file
+\item \errcode{ENOTBLK} \textit{Block device required}. Si è specificato un file
che non è un \textit{block device} in un contesto in cui era necessario
specificare un \textit{block device} (ad esempio si è tentato di montare un
file ordinario).
-\item \macro{EEXIST} \textit{File exists}. Si è specificato un file esistente
+\item \errcode{EEXIST} \textit{File exists}. Si è specificato un file esistente
in un contesto in cui ha senso solo specificare un nuovo file.
-\item \macro{EBUSY} \textit{Resource busy}. Una risorsa di sistema che non può
+\item \errcode{EBUSY} \textit{Resource busy}. Una risorsa di sistema che non può
essere condivisa è occupata. Ad esempio si è tentato di cancellare la
directory su cui si è montato un filesystem.
-\item \macro{EXDEV} \textit{Cross-device link}. Si è tentato di creare un link
+\item \errcode{EXDEV} \textit{Cross-device link}. Si è tentato di creare un link
diretto che attraversa due filesystem differenti.
-\item \macro{ENODEV} \textit{No such device}. Si è indicato un tipo di device
+\item \errcode{ENODEV} \textit{No such device}. Si è indicato un tipo di device
sbagliato ad una funzione che ne richiede uno specifico.
-\item \macro{ENOTDIR} \textit{Not a directory}. Si è specificato un file che
+\item \errcode{ENOTDIR} \textit{Not a directory}. Si è specificato un file che
non è una directory in una operazione che richiede una directory.
-\item \macro{EISDIR} \textit{Is a directory}. Il file specificato è una
+\item \errcode{EISDIR} \textit{Is a directory}. Il file specificato è una
directory, non può essere aperto in scrittura, né si possono creare o
rimuovere link diretti ad essa.
-\item \macro{EMFILE} \textit{Too many open files}. Il processo corrente ha
+\item \errcode{EMFILE} \textit{Too many open files}. Il processo corrente ha
troppi file aperti e non può aprirne altri. Anche i descrittori duplicati
vengono tenuti in conto\footnote{Il numero massimo di file aperti è
controllabile dal sistema, in Linux si può usare il comando
\cmd{ulimit}.}.
-\item \macro{ENFILE} \textit{File table overflow}. Ci sono troppi file aperti
+\item \errcode{ENFILE} \textit{File table overflow}. Ci sono troppi file aperti
nel sistema.
-\item \macro{ENOTTY} \textit{Not a terminal}. Si è tentata una operazione di
+\item \errcode{ENOTTY} \textit{Not a terminal}. Si è tentata una operazione di
controllo relativa ad un terminale su un file che non lo è.
-\item \macro{ETXTBSY} \textit{Text file busy}. Si è cercato di eseguire un
+\item \errcode{ETXTBSY} \textit{Text file busy}. Si è cercato di eseguire un
file che è aperto in scrittura, o scrivere un file che è in esecuzione.
-\item \macro{EFBIG} \textit{File too big}. Si è ecceduto il limite imposto dal
+\item \errcode{EFBIG} \textit{File too big}. Si è ecceduto il limite imposto dal
sistema sulla dimensione massima che un file può avere.
-\item \macro{ENOSPC} \textit{No space left on device}. la directory in cui si
+\item \errcode{ENOSPC} \textit{No space left on device}. la directory in cui si
vuole creare il link non ha spazio per ulteriori voci.
-\item \macro{ESPIPE} \textit{Invalid seek operation}.
-\item \macro{EROFS} \textit{Read-only file system}. il file risiede su un filesystem read-only.
-\item \macro{EMLINK} \textit{Too many links}. Ci sono troppi link al file (il
- numero massimo è specificato dalla variabile \macro{LINK\_MAX}, vedi
+\item \errcode{ESPIPE} \textit{Invalid seek operation}.
+\item \errcode{EROFS} \textit{Read-only file system}. il file risiede su un
+ filesystem read-only.
+\item \errcode{EMLINK} \textit{Too many links}. Ci sono troppi link al file (il
+ numero massimo è specificato dalla variabile \const{LINK\_MAX}, vedi
\secref{sec:sys_limits}).
-\item \macro{EPIPE} \textit{Broken pipe}. Non c'è un processo che stia
+\item \errcode{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 predefinita è
+ errore genera anche un segnale \const{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
- quando l'operazione richiede che lo sia. È l'errore tipico che si ha quando
- si cerca di cancellare una directory contenente dei file.
-\item \macro{EUSERS} \textit{Too many users}. Troppi utenti, il sistema delle
+ che \const{SIGPIPE} non viene gestito o bloccato.
+\item \errcode{ENOTEMPTY} \textit{Directory not empty}. La directory non è
+ vuota quando l'operazione richiede che lo sia. È l'errore tipico che si ha
+ quando si cerca di cancellare una directory contenente dei file.
+\item \errcode{EUSERS} \textit{Too many users}. Troppi utenti, il sistema delle
quote rileva troppi utenti nel sistema.
-\item \macro{EDQUOT} \textit{Quota exceeded}. Si è ecceduta la quota di disco
+\item \errcode{EDQUOT} \textit{Quota exceeded}. Si è ecceduta la quota di disco
dell'utente.
-\item \macro{ESTALE} \textit{Stale NFS file handle}. Indica un problema
+\item \errcode{ESTALE} \textit{Stale NFS file handle}. Indica un problema
interno a NFS causato da cambiamenti del filesystem del sistema remoto. Per
recuperare questa condizione in genere è necessario smontare e rimontare il
filesystem NFS.
-\item \macro{EREMOTE} \textit{Object is remote}. Si è fatto un tentativo di
+\item \errcode{EREMOTE} \textit{Object is remote}. Si è fatto un tentativo di
montare via NFS un filesystem remoto con un nome che già specifica un
filesystem montato via NFS.
-\item \macro{ENOLCK} \textit{No locks available}. È usato dalle utilità per la
- gestione del file lock; non viene generato da un sistema GNU, ma può
+\item \errcode{ENOLCK} \textit{No locks available}. È usato dalle utilità per
+ la gestione del file lock; non viene generato da un sistema GNU, ma può
risultare da un'operazione su un server NFS di un altro sistema.
-\item \macro{EFTYPE} \textit{Inappropriate file type or format}. Il file è di
+\item \errcode{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 impostare lo \textit{sticky bit} su un file che non è una directory.
gestione dei processi.
\begin{description}
-\item \macro{ESRCH} \textit{No process matches the specified process ID}. Non
+\item \errcode{ESRCH} \textit{No process matches the specified process ID}. Non
esiste un processo con il \acr{pid} specificato.
-\item \macro{E2BIG} \textit{Argument list too long}. Lista degli argomenti
+\item \errcode{E2BIG} \textit{Argument list too long}. Lista degli argomenti
troppo lunga: è una condizione prevista da POSIX quando la lista degli
argomenti passata ad una delle funzioni \func{exec} occupa troppa memoria,
non può mai accadere in GNU/Linux.
-\item \macro{ECHILD} \textit{There are no child processes}. Non esiste un
+\item \errcode{ECHILD} \textit{There are no child processes}. Non esiste un
processo figlio. Viene rilevato dalle funzioni per la gestione dei processi
figli.
-%\item \macro{EPROCLIM} \textit{}. Il limite dell'utente per nuovi processi
+%\item \errcode{EPROCLIM} \textit{}. Il limite dell'utente per nuovi processi
% sarà ecceduto alla prossima \func{fork}. (non credo esista in linux)
\end{description}
\begin{description}
-\item \macro{ENOTSOCK} \textit{Socket operation on non-socket}. Si è tentata
+\item \errcode{ENOTSOCK} \textit{Socket operation on non-socket}. Si è tentata
un'operazione su un file descriptor che non è un socket quando invece era
richiesto un socket.
-\item \macro{EMSGSIZE} \textit{Message too long}. Le dimensioni di un
+\item \errcode{EMSGSIZE} \textit{Message too long}. Le dimensioni di un
messaggio inviato su un socket sono eccedono la massima lunghezza supportata.
-\item \macro{EPROTOTYPE} \textit{Protocol wrong type for socket}. Protocollo
+\item \errcode{EPROTOTYPE} \textit{Protocol wrong type for socket}. Protocollo
sbagliato per il socket. Il socket usato non supporta il protocollo di
comunicazione richiesto.
-\item \macro{ENOPROTOOPT} \textit{Protocol not available}. Protocollo non
+\item \errcode{ENOPROTOOPT} \textit{Protocol not available}. Protocollo non
disponibile. Si è richiesta un'opzione per il socket non disponibile con il
protocollo usato.
-\item \macro{EPROTONOSUPPORT} \textit{Protocol not supported}. Protocollo non
+\item \errcode{EPROTONOSUPPORT} \textit{Protocol not supported}. Protocollo non
supportato. Il tipo di socket non supporta il protocollo richiesto (un
probabile errore nella specificazione del protocollo).
-\item \macro{ESOCKTNOSUPPORT} \textit{Socket type not supported}. Socket non
+\item \errcode{ESOCKTNOSUPPORT} \textit{Socket type not supported}. Socket non
supportato. Il tipo di socket scelto non è supportato.
-\item \macro{EOPNOTSUPP} \textit{Operation not supported on transport
+\item \errcode{EOPNOTSUPP} \textit{Operation not supported on transport
endpoint}. L'operazione richiesta non è supportata. Alcune funzioni non
hanno senso per tutti i tipi di socket, ed altre non sono implementate per
tutti i protocolli di trasmissione. Questo errore quando un socket non
supporta una particolare operazione, e costituisce una indicazione generica
che il server non sa cosa fare per la chiamata effettuata.
-\item \macro{EPFNOSUPPORT} \textit{Protocol family not supported}. Famiglia di
- protocolli non supportata. La famiglia di protocolli richiesta non è
+\item \errcode{EPFNOSUPPORT} \textit{Protocol family not supported}. Famiglia
+ di protocolli non supportata. La famiglia di protocolli richiesta non è
supportata.
-\item \macro{EAFNOSUPPORT} \textit{Address family not supported by protocol}.
+\item \errcode{EAFNOSUPPORT} \textit{Address family not supported by protocol}.
Famiglia di indirizzi non supportata. La famiglia di indirizzi richiesta non
è supportata, o è inconsistente con il protocollo usato dal socket.
-\item \macro{EADDRINUSE} \textit{Address already in use}. L'indirizzo del
+\item \errcode{EADDRINUSE} \textit{Address already in use}. L'indirizzo del
socket richiesto è gia utilizzato (ad esempio si è richiesto il \func{bind}
per una porta già in uso).
-\item \macro{EADDRNOTAVAIL} \textit{Cannot assign requested address}.
+\item \errcode{EADDRNOTAVAIL} \textit{Cannot assign requested address}.
L'indirizzo richiesto non è disponibile (ad esempio si è cercato di dare al
socket un nome che non corrisponde al nome della stazione locale).
-\item \macro{ENETDOWN} \textit{Network is down}. L'operazione sul socket è
+\item \errcode{ENETDOWN} \textit{Network is down}. L'operazione sul socket è
fallita perché la rete è sconnessa.
-\item \macro{ENETUNREACH} \textit{Network is unreachable}. L'operazione è
+\item \errcode{ENETUNREACH} \textit{Network is unreachable}. L'operazione è
fallita perché l'indirizzo richiesto è irraggiungibile (ad esempio la
sottorete della stazione remota è irraggiungibile).
-\item \macro{ENETRESET} \textit{Network dropped connection because of reset}.
+\item \errcode{ENETRESET} \textit{Network dropped connection because of reset}.
Una connessione è stata cancellata perché l'host remoto è caduto.
-\item \macro{ECONNABORTED} \textit{Software caused connection abort}. Una
+\item \errcode{ECONNABORTED} \textit{Software caused connection abort}. Una
connessione è stata abortita localmente.
-\item \macro{ECONNRESET} \textit{Connection reset by peer}. Una connessione è
+\item \errcode{ECONNRESET} \textit{Connection reset by peer}. Una connessione è
stata chiusa per ragioni fuori dal controllo dell'host locale, come il
riavvio di una macchina remota o un qualche errore non recuperabile sul
protocollo.
-\item \macro{ENOBUFS} \textit{No buffer space available}. Tutti i buffer per
+\item \errcode{ENOBUFS} \textit{No buffer space available}. Tutti i buffer per
le operazioni di I/O del kernel sono occupati. In generale questo errore è
- sinonimo di \macro{ENOMEM}, ma attiene alle funzioni di input/output. In
+ sinonimo di \errcode{ENOMEM}, ma attiene alle funzioni di input/output. In
caso di operazioni sulla rete si può ottenere questo errore invece
dell'altro.
-\item \macro{EISCONN} \textit{Transport endpoint is already connected}. Si è
+\item \errcode{EISCONN} \textit{Transport endpoint is already connected}. Si è
tentato di connettere un socket che è gia connesso.
-\item \macro{ENOTCONN} \textit{Transport endpoint is not connected}. Il socket
- non è connesso a niente. Si ottiene questo errore quando si cerca di
+\item \errcode{ENOTCONN} \textit{Transport endpoint is not connected}. Il
+ socket non è connesso a niente. Si ottiene questo errore quando si cerca di
trasmettere dati su un socket senza avere specificato in precedenza la loro
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
+ l'errore che si ottiene è \errcode{EDESTADDRREQ}.
+\item \errcode{EDESTADDRREQ} \textit{Destination address required}. Non c'è un
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
+\item \errcode{ESHUTDOWN} \textit{Cannot send after transport endpoint
shutdown}. Il socket su cui si cerca di inviare dei dati ha avuto uno
shutdown.
-\item \macro{ETOOMANYREFS} \textit{Too many references: cannot splice}. La
+\item \errcode{ETOOMANYREFS} \textit{Too many references: cannot splice}. La
glibc dice ???
-\item \macro{ETIMEDOUT} \textit{Connection timed out}. Un'operazione sul
+\item \errcode{ETIMEDOUT} \textit{Connection timed out}. Un'operazione sul
socket non ha avuto risposta entro il periodo di timeout.
-\item \macro{ECONNREFUSED} \textit{Connection refused}. Un host remoto ha
+\item \errcode{ECONNREFUSED} \textit{Connection refused}. Un host remoto ha
rifiutato la connessione (in genere dipende dal fatto che non c'è un server
per soddisfare il servizio richiesto).
-\item \macro{EHOSTDOWN} \textit{Host is down}. L'host remoto di una
+\item \errcode{EHOSTDOWN} \textit{Host is down}. L'host remoto di una
connessione è giù.
-\item \macro{EHOSTUNREACH} \textit{No route to host}. L'host remoto di una
+\item \errcode{EHOSTUNREACH} \textit{No route to host}. L'host remoto di una
connessione non è raggiungibile.
\end{description}
specificati nelle sezioni precedenti.
\begin{description}
-\item \macro{EINTR} \textit{Interrupted function call}. Una funzione di
+\item \errcode{EINTR} \textit{Interrupted function call}. Una funzione di
libreria è stata interrotta. In genere questo avviene causa di un segnale
asincrono al processo che impedisce la conclusione della chiamata. In questo
caso è necessario ripetere la chiamata alla funzione.
-\item \macro{ENOMEM} \textit{No memory available}. Il kernel non è in grado di
- allocare ulteriore memoria per completare l'operazione richiesta.
-\item \macro{EDEADLK} \textit{Deadlock avoided}. L'allocazione di una risorsa
- avrebbe causato un deadlock. Non sempre il sistema è in grado di riconoscere
- queste situazioni, nel qual caso si avrebbe in blocco.
-\item \macro{EFAULT} \textit{Bad address}. Una stringa passata come parametro
+\item \errcode{ENOMEM} \textit{No memory available}. Il kernel non è in grado
+ di allocare ulteriore memoria per completare l'operazione richiesta.
+\item \errcode{EDEADLK} \textit{Deadlock avoided}. L'allocazione di una
+ risorsa avrebbe causato un \textit{deadlock}\index{deadlock}. Non sempre il
+ sistema è in grado di riconoscere queste situazioni, nel qual caso si
+ avrebbe in blocco.
+\item \errcode{EFAULT} \textit{Bad address}. Una stringa passata come parametro
è fuori dello spazio di indirizzi del processo, in genere questa situazione
provoca l'emissione di un segnale di \textit{segment violation}
- (\macro{SIGSEGV}).
-\item \macro{EINVAL} \textit{Invalid argument}. Errore utilizzato per
+ (\const{SIGSEGV}).
+\item \errcode{EINVAL} \textit{Invalid argument}. Errore utilizzato per
segnalare vari tipi di problemi dovuti all'aver passato un argomento
sbagliato ad una funzione di libreria.
-\item \macro{EDOM} \textit{Domain error}. È usato dalle funzioni matematiche
+\item \errcode{EDOM} \textit{Domain error}. È usato dalle funzioni matematiche
quando il valore di un argomento è al di fuori dell'intervallo in cui sono
definite.
-\item \macro{ERANGE} \textit{Range error}. È usato dalle funzioni matematiche
+\item \errcode{ERANGE} \textit{Range error}. È usato dalle funzioni matematiche
quando il risultato non è rappresentabile a causa di un overflow o di un
underflow.
-\item \macro{EAGAIN} \textit{Resource temporarily unavailable}. La funzione è
+\item \errcode{EAGAIN} \textit{Resource temporarily unavailable}. La funzione è
fallita ma potrebbe funzionare se la chiamata fosse ripetuta. Questo errore
accade in due tipologie di situazioni:
\begin{itemize}
\item Si è effettuata un'operazione che si sarebbe bloccata su un oggetto
che è stato posto in modalità non bloccante. Nei vecchi sistemi questo era
- un codice diverso, \macro{EWOULDBLOCK}. In genere questo ha a che fare con
- file o socket, per i quali si può usare la funzione \func{select} per
+ un codice diverso, \errcode{EWOULDBLOCK}. In genere questo ha a che fare
+ con file o socket, per i quali si può usare la funzione \func{select} per
vedere quando l'operazione richiesta (lettura, scrittura o connessione)
diventa possibile.
\item Indica la carenza di una risorsa di sistema che non è al momento
carenza è spesso indice di qualcosa che non va nel sistema, è pertanto
opportuno segnalare esplicitamente questo tipo di errori.
\end{itemize}
-\item \macro{EWOULDBLOCK} \textit{Operation would block}. In Linux è identico
- a \macro{EAGAIN}.
-\item \macro{EINPROGRESS} \textit{Operation now in progress}. Operazione in
+\item \errcode{EWOULDBLOCK} \textit{Operation would block}. In Linux è identico
+ a \errcode{EAGAIN}.
+\item \errcode{EINPROGRESS} \textit{Operation now in progress}. Operazione in
corso. Un'operazione che non può essere completata immediatamente è stata
avviata su un oggetto posto in modalità non-bloccante. Questo errore viene
riportato per operazioni che si dovrebbero sempre bloccare (come per una
- \func{connect}) e che pertanto non possono riportare \macro{EAGAIN},
+ \func{connect}) e che pertanto non possono riportare \errcode{EAGAIN},
l'errore indica che l'operazione è stata avviata correttamente e occorrerà
del tempo perché si possa completare. La ripetizione della chiamata darebbe
- luogo ad un errore \macro{EALREADY}.
-\item \macro{EALREADY} \textit{Operation already in progress}. L'operazione è
+ luogo ad un errore \errcode{EALREADY}.
+\item \errcode{EALREADY} \textit{Operation already in progress}. L'operazione è
già in corso. Si è tentata un'operazione già in corso su un oggetto posto in
modalità non-bloccante.
-\item \macro{ENOSYS} \textit{Function not implemented}. Indica che la funzione
- non è implementata o nelle librerie del C o nel kernel.
-\item \macro{ENOTSUP} \textit{Not supported}. Una funzione ritorna questo
+\item \errcode{ENOSYS} \textit{Function not implemented}. Indica che la
+ funzione non è supportata o nelle librerie del C o nel kernel. Può dipendere
+ sia dalla mancanza di una implementazione, che dal fatto che non si è
+ abilitato l'opportuno supporto nel kernel; nel caso di Linux questo può
+ voler dire anche che un modulo necessario non è stato caricato nel sistema.
+\item \errcode{ENOTSUP} \textit{Not supported}. Una funzione ritorna questo
errore quando i parametri sono validi ma l'operazione richiesta non è
supportata. Questo significa che la funzione non implementa quel particolare
comando o opzione o che, in caso di oggetti specifici (file descriptor o
altro) non è in grado di supportare i parametri richiesti.
-\item \macro{EILSEQ} \textit{Illegal byte sequence}. Nella decodifica di un
+\item \errcode{EILSEQ} \textit{Illegal byte sequence}. Nella decodifica di un
carattere multibyte si è avuta una sequenza errata o incompleta o si è
specificato un valore non valido.
\end{description}
\begin{description}
-%\item \macro{EBADRPC} \textit{}.
-%\item \macro{ERPCMISMATCH} \textit{}.
-%\item \macro{EPROGUNAVAIL} \textit{}.
-%\item \macro{EPROGMISMATCH} \textit{}.
-%\item \macro{EPROCUNAVAIL} \textit{}.
-%\item \macro{EAUTH} \textit{}.
-%\item \macro{ENEEDAUTH} \textit{}.
-%\item \macro{EBACKGROUND} \textit{}.
-%\item \macro{EDIED} \textit{}.
-%\item \macro{ED} \textit{}.
-%\item \macro{EGREGIOUS} \textit{}.
-%\item \macro{EIEIO} \textit{}.
-%\item \macro{EGRATUITOUS} \textit{}.
-\item \macro{EBADMSG} \textit{Not a data message}.
-\item \macro{EIDRM} \textit{Identifier removed}.
-\item \macro{EMULTIHOP} \textit{Multihop attempted}.
-\item \macro{ENODATA} \textit{No data available}.
-\item \macro{ENOLINK} \textit{Link has been severed}.
-\item \macro{ENOMSG} \textit{No message of desired type}.
-\item \macro{ENOSR} \textit{Out of streams resources}.
-\item \macro{ENOSTR} \textit{Device not a stream}.
-\item \macro{EOVERFLOW} \textit{Value too large for defined data type}.
-\item \macro{EPROTO} \textit{Protocol error}.
-\item \macro{ETIME} \textit{Timer expired}.
+%\item \errcode{EBADRPC} \textit{}.
+%\item \errcode{ERPCMISMATCH} \textit{}.
+%\item \errcode{EPROGUNAVAIL} \textit{}.
+%\item \errcode{EPROGMISMATCH} \textit{}.
+%\item \errcode{EPROCUNAVAIL} \textit{}.
+%\item \errcode{EAUTH} \textit{}.
+%\item \errcode{ENEEDAUTH} \textit{}.
+%\item \errcode{EBACKGROUND} \textit{}.
+%\item \errcode{EDIED} \textit{}.
+%\item \errcode{ED} \textit{}.
+%\item \errcode{EGREGIOUS} \textit{}.
+%\item \errcode{EIEIO} \textit{}.
+%\item \errcode{EGRATUITOUS} \textit{}.
+\item \errcode{EBADMSG} \textit{Not a data message}.
+\item \errcode{EIDRM} \textit{Identifier removed}. Indica che l'oggetto del
+ \textit{SysV IPC} cui si fa riferimento è stato cancellato.
+\item \errcode{EMULTIHOP} \textit{Multihop attempted}.
+\item \errcode{ENODATA} \textit{No data available}.
+\item \errcode{ENOLINK} \textit{Link has been severed}.
+\item \errcode{ENOMSG} \textit{No message of desired type}.
+\item \errcode{ENOSR} \textit{Out of streams resources}.
+\item \errcode{ENOSTR} \textit{Device not a stream}.
+\item \errcode{EOVERFLOW} \textit{Value too large for defined data type}.
+\item \errcode{EPROTO} \textit{Protocol error}.
+\item \errcode{ETIME} \textit{Timer expired}.
\end{description}
call (TODO verificare i dettagli, eventualmente cassare).
\begin{description}
-\item \macro{ERESTART} \textit{Interrupted system call should be restarted}.
-\item \macro{ECHRNG} \textit{Channel number out of range}.
-\item \macro{EL2NSYNC} \textit{Level 2 not synchronized}.
-\item \macro{EL3HLT} \textit{Level 3 halted}.
-\item \macro{EL3RST} \textit{Level 3 reset}.
-\item \macro{ELNRNG} \textit{Link number out of range}.
-\item \macro{EUNATCH} \textit{Protocol driver not attached}.
-\item \macro{ENOCSI} \textit{No CSI structure available}.
-\item \macro{EL2HLT} \textit{Level 2 halted}.
-\item \macro{EBADE} \textit{Invalid exchange}.
-\item \macro{EBADR} \textit{Invalid request descriptor}.
-\item \macro{EXFULL} \textit{Exchange full}.
-\item \macro{ENOANO} \textit{No anode}.
-\item \macro{EBADRQC} \textit{Invalid request code}.
-\item \macro{EBADSLT} \textit{Invalid slot}.
-\item \macro{EDEADLOCK} Identico a \macro{EDEADLK}.
-\item \macro{EBFONT} \textit{Bad font file format}.
-\item \macro{ENONET} \textit{Machine is not on the network}.
-\item \macro{ENOPKG} \textit{Package not installed}.
-\item \macro{EADV} \textit{Advertise error}.
-\item \macro{ESRMNT} \textit{Srmount error}.
-\item \macro{ECOMM} \textit{Communication error on send}.
-\item \macro{EDOTDOT} \textit{RFS specific error}.
-\item \macro{ENOTUNIQ} \textit{Name not unique on network}.
-\item \macro{EBADFD} \textit{File descriptor in bad state}.
-\item \macro{EREMCHG} \textit{Remote address changed}.
-\item \macro{ELIBACC} \textit{Can not access a needed shared library}.
-\item \macro{ELIBBAD} \textit{Accessing a corrupted shared library}.
-\item \macro{ELIBSCN} \textit{.lib section in a.out corrupted}.
-\item \macro{ELIBMAX} \textit{Attempting to link in too many shared libraries}.
-\item \macro{ELIBEXEC} \textit{Cannot exec a shared library directly}.
-\item \macro{ESTRPIPE} \textit{Streams pipe error}.
-\item \macro{EUCLEAN} \textit{Structure needs cleaning}.
-\item \macro{ENAVAIL} \textit{No XENIX semaphores available}.
-\item \macro{EISNAM} \textit{Is a named type file}.
-\item \macro{EREMOTEIO} \textit{Remote I/O error}.
-\item \macro{ENOMEDIUM} \textit{No medium found}.
-\item \macro{EMEDIUMTYPE} \textit{Wrong medium type}.
-\item \macro{} \textit{}.
+\item \errcode{ERESTART} \textit{Interrupted system call should be restarted}.
+\item \errcode{ECHRNG} \textit{Channel number out of range}.
+\item \errcode{EL2NSYNC} \textit{Level 2 not synchronized}.
+\item \errcode{EL3HLT} \textit{Level 3 halted}.
+\item \errcode{EL3RST} \textit{Level 3 reset}.
+\item \errcode{ELNRNG} \textit{Link number out of range}.
+\item \errcode{EUNATCH} \textit{Protocol driver not attached}.
+\item \errcode{ENOCSI} \textit{No CSI structure available}.
+\item \errcode{EL2HLT} \textit{Level 2 halted}.
+\item \errcode{EBADE} \textit{Invalid exchange}.
+\item \errcode{EBADR} \textit{Invalid request descriptor}.
+\item \errcode{EXFULL} \textit{Exchange full}.
+\item \errcode{ENOANO} \textit{No anode}.
+\item \errcode{EBADRQC} \textit{Invalid request code}.
+\item \errcode{EBADSLT} \textit{Invalid slot}.
+\item \errcode{EDEADLOCK} Identico a \errcode{EDEADLK}.
+\item \errcode{EBFONT} \textit{Bad font file format}.
+\item \errcode{ENONET} \textit{Machine is not on the network}.
+\item \errcode{ENOPKG} \textit{Package not installed}.
+\item \errcode{EADV} \textit{Advertise error}.
+\item \errcode{ESRMNT} \textit{Srmount error}.
+\item \errcode{ECOMM} \textit{Communication error on send}.
+\item \errcode{EDOTDOT} \textit{RFS specific error}.
+\item \errcode{ENOTUNIQ} \textit{Name not unique on network}.
+\item \errcode{EBADFD} \textit{File descriptor in bad state}.
+\item \errcode{EREMCHG} \textit{Remote address changed}.
+\item \errcode{ELIBACC} \textit{Can not access a needed shared library}.
+\item \errcode{ELIBBAD} \textit{Accessing a corrupted shared library}.
+\item \errcode{ELIBSCN} \textit{.lib section in a.out corrupted}.
+\item \errcode{ELIBMAX} \textit{Attempting to link in too many shared
+ libraries}.
+\item \errcode{ELIBEXEC} \textit{Cannot exec a shared library directly}.
+\item \errcode{ESTRPIPE} \textit{Streams pipe error}.
+\item \errcode{EUCLEAN} \textit{Structure needs cleaning}.
+\item \errcode{ENAVAIL} \textit{No XENIX semaphores available}.
+\item \errcode{EISNAM} \textit{Is a named type file}.
+\item \errcode{EREMOTEIO} \textit{Remote I/O error}.
+\item \errcode{ENOMEDIUM} \textit{No medium found}.
+\item \errcode{EMEDIUMTYPE} \textit{Wrong medium type}.
\end{description}
Abbiamo già accennato in \secref{sec:file_open} che è possibile prevenire
questo tipo di comportamento aprendo un file in modalità
-\textsl{non-bloccante}, attraverso l'uso del flag \macro{O\_NONBLOCK} nella
+\textsl{non-bloccante}, attraverso l'uso del flag \const{O\_NONBLOCK} nella
chiamata di \func{open}. In questo caso le funzioni di input/output che
altrimenti si sarebbero bloccate ritornano immediatamente, restituendo
-l'errore \macro{EAGAIN}.
+l'errore \errcode{EAGAIN}.
L'utilizzo di questa modalità di I/O permette di risolvere il problema
controllando a turno i vari file descriptor, in un ciclo in cui si ripete
descriptor (anche nullo) che sono attivi, e -1 in caso di errore, nel qual
caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
+ \item[\errcode{EBADF}] Si è specificato un file descriptor sbagliato in uno
degli insiemi.
- \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
- \item[\macro{EINVAL}] Si è specificato per \param{n} un valore negativo.
+ \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale.
+ \item[\errcode{EINVAL}] Si è specificato per \param{n} un valore negativo.
\end{errlist}
- ed inoltre \macro{ENOMEM}.
+ ed inoltre \const{ENOMEM}.
}
\end{functions}
\end{functions}
In genere un \textit{file descriptor set} può contenere fino ad un massimo di
-\macro{FD\_SETSIZE} file descriptor. Questo valore in origine corrispondeva
+\const{FD\_SETSIZE} file descriptor. Questo valore in origine corrispondeva
al limite per il numero massimo di file aperti\footnote{ad esempio in Linux,
fino alla serie 2.0.x, c'era un limite di 256 file per processo.}, ma
quando, come nelle versioni più recenti del kernel, non c'è più un limite
La funzione inoltre richiede anche di specificare, tramite l'argomento
\param{n}, un valore massimo del numero dei file descriptor usati
-nell'insieme; si può usare il già citato \macro{FD\_SETSIZE}, oppure il numero
+nell'insieme; si può usare il già citato \const{FD\_SETSIZE}, oppure il numero
più alto dei file descriptor usati nei tre insiemi, aumentato di uno.
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 impostato a \macro{NULL} la funzione attende
+funzione ritorni; se impostato a \val{NULL} la funzione attende
indefinitamente. Si può specificare anche un tempo nullo (cioè una \var{struct
timeval} con i campi impostati a zero), qualora si voglia semplicemente
controllare lo stato corrente dei file descriptor.
il valore zero indica sempre che si è raggiunto un timeout. Ciascuno dei tre
insiemi viene sovrascritto per indicare quale file descriptor è pronto per le
operazioni ad esso relative, in modo da poterlo controllare con la macro
-\macro{FD\_ISSET}. In caso di errore la funzione restituisce -1 e gli insiemi
+\const{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},
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 è
+\errcode{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
caso di successo, o 0 se c'è stato un timeout; in caso di errore viene
restituito -1 ed \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
+ \item[\errcode{EBADF}] Si è specificato un file descriptor sbagliato in uno
degli insiemi.
- \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
+ \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale.
\end{errlist}
- ed inoltre \macro{EFAULT} e \macro{ENOMEM}.}
+ ed inoltre \const{EFAULT} e \const{ENOMEM}.}
\end{prototype}
La funzione tiene sotto controllo un numero \param{ndfs} di file descriptor
\textbf{Flag} & \textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{POLLIN} & 0x001 & È possibile la lettura immediata.\\
- \macro{POLLPRI} & 0x002 & Sono presenti dati urgenti.\\
- \macro{POLLOUT} & 0x004 & È possibile la scrittura immediata.\\
+ \const{POLLIN} & 0x001 & È possibile la lettura immediata.\\
+ \const{POLLPRI} & 0x002 & Sono presenti dati urgenti.\\
+ \const{POLLOUT} & 0x004 & È possibile la scrittura immediata.\\
\hline
- \macro{POLLERR} & 0x008 & C'è una condizione di errore.\\
- \macro{POLLHUP} & 0x010 & Si è verificato un hung-up.\\
- \macro{POLLNVAL} & 0x020 & Il file descriptor non è aperto.\\
+ \const{POLLERR} & 0x008 & C'è una condizione di errore.\\
+ \const{POLLHUP} & 0x010 & Si è verificato un hung-up.\\
+ \const{POLLNVAL} & 0x020 & Il file descriptor non è aperto.\\
\hline
- \macro{POLLRDNORM}& 0x040 & Sono disponibili in lettura dati normali.\\
- \macro{POLLRDBAND}& 0x080 & Sono disponibili in lettura dati ad alta
+ \const{POLLRDNORM}& 0x040 & Sono disponibili in lettura dati normali.\\
+ \const{POLLRDBAND}& 0x080 & Sono disponibili in lettura dati ad alta
priorità. \\
- \macro{POLLWRNORM}& 0x100 & È possibile la scrittura di dati normali. \\
- \macro{POLLWRBAND}& 0x200 & È possibile la scrittura di dati ad
+ \const{POLLWRNORM}& 0x100 & È possibile la scrittura di dati normali. \\
+ \const{POLLWRBAND}& 0x200 & È possibile la scrittura di dati ad
alta priorità. \\
- \macro{POLLMSG} & 0x400 & Estensione propria di Linux.\\
+ \const{POLLMSG} & 0x400 & Estensione propria di Linux.\\
\hline
\end{tabular}
\caption{Costanti per l'identificazione dei vari bit dei campi
2.1. Le \acr{libc4} e \acr{libc5} non contengono questo header, le
\acr{glibc} 2.0 contengono una definizione sbagliata di \func{psignal},
senza l'argomento \param{sigmask}, la definizione corretta è presente dalle
- \acr{glibc} 2.1-2.2.1 se si è definito \macro{\_GNU\_SOURCE} e nelle
- \acr{glibc} 2.2.2-2.2.4 se si è definito \macro{\_XOPEN\_SOURCE} con valore
+ \acr{glibc} 2.1-2.2.1 se si è definito \const{\_GNU\_SOURCE} e nelle
+ \acr{glibc} 2.2.2-2.2.4 se si è definito \const{\_XOPEN\_SOURCE} con valore
maggiore di 600.} il cui prototipo è:
\begin{prototype}{sys/select.h}
{int pselect(int n, fd\_set *readfds, fd\_set *writefds, fd\_set *exceptfds,
descriptor (anche nullo) che sono attivi, e -1 in caso di errore, nel qual
caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
+ \item[\errcode{EBADF}] Si è specificato un file descriptor sbagliato in uno
degli insiemi.
- \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
- \item[\macro{EINVAL}] Si è specificato per \param{n} un valore negativo.
+ \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale.
+ \item[\errcode{EINVAL}] Si è specificato per \param{n} un valore negativo.
\end{errlist}
- ed inoltre \macro{ENOMEM}.}
+ ed inoltre \const{ENOMEM}.}
\end{prototype}
La funzione è sostanzialmente identica a \func{select}, solo che usa una
operazioni di calcolo e quelle di I/O.
Abbiamo accennato in \secref{sec:file_open} che è possibile, attraverso l'uso
-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
+del flag \const{O\_ASYNC},\footnote{l'uso del flag di \const{O\_ASYNC} e dei
+ comandi \const{F\_SETOWN} e \const{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à impostando questo flag attraverso
-l'uso di \func{fcntl} con il comando \macro{F\_SETFL} (vedi
+l'uso di \func{fcntl} con il comando \const{F\_SETFL} (vedi
\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
descriptor; quello che succede è che il sistema genera un segnale (normalmente
-\macro{SIGIO}, ma è possibile usarne altri) tutte le volte che diventa
+\const{SIGIO}, ma è possibile usarne altri) tutte le volte che diventa
possibile leggere o scrivere dal file descriptor che si è posto in questa
-modalità. Si può inoltre selezionare, con il comando \macro{F\_SETOWN} di
+modalità. Si può inoltre selezionare, con il comando \const{F\_SETOWN} di
\func{fcntl}, quale processo (o gruppo di processi) riceverà il segnale.
In questo modo si può evitare l'uso delle funzioni \func{poll} o \func{select}
Per far questo però occorre utilizzare le funzionalità dei segnali real-time
(vedi \secref{sec:sig_real_time}) impostando esplicitamente con il comando
-\macro{F\_SETSIG} di \func{fcntl} un segnale real-time da inviare in caso di
-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
+\const{F\_SETSIG} di \func{fcntl} un segnale real-time da inviare in caso di
+I/O asincrono (il segnale predefinito è \const{SIGIO}). In questo caso il
+manipolatore tutte le volte che riceverà \const{SI\_SIGIO} come valore del
+campo \var{si\_code}\footnote{il valore resta \const{SI\_SIGIO} qualunque sia
il segnale che si è associato all'I/O asincrono, ed indica appunto che il
segnale è stato generato a causa di attività nell'I/O asincrono.} di
\type{siginfo\_t}, troverà nel campo \var{si\_fd} il valore del file
\textit{asyncronous I/O control block}), che viene passata come argomento a
tutte le funzioni dell'interfaccia. La sua definizione, come effettuata in
\file{aio.h}, è riportata in \figref{fig:file_aiocb}. Nello steso file è
-definita la macro \macro{\_POSIX\_ASYNCHRONOUS\_IO}, che dichiara la
+definita la macro \const{\_POSIX\_ASYNCHRONOUS\_IO}, che dichiara la
disponibilità dell'interfaccia per l'I/O asincrono.
\begin{figure}[!htb]
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 impostata a
+ le macro \const{\_POSIX\_PRIORITIZED\_IO}, e
+ \const{\_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.
riportata in \secref{fig:file_sigevent}; il campo \var{sigev\_notify} è quello
che indica le modalità della notifica, esso può assumere i tre valori:
\begin{basedescript}{\desclabelwidth{3.0cm}}
-\item[\macro{SIGEV\_NONE}] Non viene inviata nessuna notifica.
-\item[\macro{SIGEV\_SIGNAL}] La notifica viene effettuata inviando al processo
+\item[\const{SIGEV\_NONE}] Non viene inviata nessuna notifica.
+\item[\const{SIGEV\_SIGNAL}] La notifica viene effettuata inviando al processo
chiamante il segnale specificato nel campo \var{sigev\_signo}, se il
- manipolatore è installato con \macro{SA\_SIGINFO}, il gli verrà restituito
+ manipolatore è installato con \const{SA\_SIGINFO}, il gli verrà restituito
il valore di \var{sigev\_value} in come valore del campo \var{si\_value} per
\type{siginfo\_t}.
-\item[\macro{SIGEV\_THREAD}] La notifica viene effettuata creando un nuovo
+\item[\const{SIGEV\_THREAD}] La notifica viene effettuata creando un nuovo
thread che esegue la funzione specificata da \var{sigev\_notify\_function},
con gli attributi specificati da \var{sigev\_notify\_attribute}.
\end{basedescript}
\bodydesc{Le funzioni restituiscono 0 in caso di successo, e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato.
- \item[\macro{ENOSYS}] La funzione non è implementata.
- \item[\macro{EINVAL}] Si è specificato un valore non valido per i campi
+ \item[\errcode{EBADF}] Si è specificato un file descriptor sbagliato.
+ \item[\errcode{ENOSYS}] La funzione non è implementata.
+ \item[\errcode{EINVAL}] Si è specificato un valore non valido per i campi
\var{aio\_offset} o \var{aio\_reqprio} di \param{aiocbp}.
- \item[\macro{EAGAIN}] La coda delle richieste è momentaneamente piena.
+ \item[\errcode{EAGAIN}] La coda delle richieste è momentaneamente piena.
\end{errlist}
}
\end{functions}
Entrambe le funzioni ritornano immediatamente dopo aver messo in coda la
-richiesta, o in caso di errore. Non è detto che gli errori \macro{EBADF} ed
-\macro{EINVAL} siano rilevati immediatamente al momento della chiamata,
+richiesta, o in caso di errore. Non è detto che gli errori \errcode{EBADF} ed
+\errcode{EINVAL} siano rilevati immediatamente al momento della chiamata,
potrebbero anche emergere nelle fasi successive delle operazioni. Lettura e
scrittura avvengono alla posizione indicata da \var{aio\_offset}, a meno che
il file non sia stato aperto in \textit{append mode} (vedi
\end{prototype}
Se l'operazione non si è ancora completata viene restituito l'errore di
-\macro{EINPROGRESS}. La funzione ritorna zero quando l'operazione si è
+\errcode{EINPROGRESS}. La funzione ritorna zero quando l'operazione si è
conclusa con successo, altrimenti restituisce il codice dell'errore
verificatosi, ed esegue la corrispondente impostazione di \var{errno}. Il
-codice può essere sia \macro{EINVAL} ed \macro{EBADF}, dovuti ad un valore
+codice può essere sia \errcode{EINVAL} ed \errcode{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}.
Una volta che si sia certi che le operazioni siano state concluse (cioè dopo
-che una chiamata ad \func{aio\_error} non ha restituito \macro{EINPROGRESS},
+che una chiamata ad \func{aio\_error} non ha restituito \errcode{EINPROGRESS},
si potrà usare la seconda funzione dell'interfaccia, \func{aio\_return}, che
permette di verificare il completamento delle operazioni di I/O asincrono; il
suo prototipo è:
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
errore, che può essere, con le stesse modalità di \func{aio\_read},
- \macro{EAGAIN}, \macro{EBADF} o \macro{EINVAL}.}
+ \const{EAGAIN}, \const{EBADF} o \const{EINVAL}.}
\end{prototype}
La funzione richiede la sincronizzazione delle operazioni di I/O, ritornando
immediatamente. L'esecuzione effettiva della sincronizzazione dovrà essere
verificata con \func{aio\_error} e \func{aio\_return} come per le operazioni
di lettura e scrittura. L'argomento \param{op} permette di indicare la
-modalità di esecuzione, se si specifica il valore \macro{O\_DSYNC} le
+modalità di esecuzione, se si specifica il valore \const{O\_DSYNC} le
operazioni saranno completate con una chiamata a \func{fdatasync}, se si
-specifica \macro{O\_SYNC} con una chiamata a \func{fsync} (per i dettagli vedi
+specifica \const{O\_SYNC} con una chiamata a \func{fsync} (per i dettagli vedi
\secref{sec:file_sync}).
Il successo della chiamata assicura la sincronizzazione delle operazioni fino
\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}, imposta \var{errno} al valore
- \macro{EBADF}.}
+ \const{EBADF}.}
\end{prototype}
La funzione permette di cancellare una operazione specifica sul file
-\param{fildes}, o tutte le operazioni pendenti, specificando \macro{NULL} come
+\param{fildes}, o tutte le operazioni pendenti, specificando \val{NULL} come
valore di \param{aiocbp}. Quando una operazione viene cancellata una
-successiva chiamata ad \func{aio\_error} riporterà \macro{ECANCELED} come
+successiva chiamata ad \func{aio\_error} riporterà \errcode{ECANCELED} come
codice di errore, ed il suo codice di ritorno sarà -1, inoltre il meccanismo
di notifica non verrà invocato. Se si specifica una operazione relativa ad un
altro file descriptor il risultato è indeterminato.
In caso di successo, i possibili valori di ritorno per \func{aio\_cancel} sono
tre (anch'essi definiti in \file{aio.h}):
\begin{basedescript}{\desclabelwidth{3.0cm}}
-\item[\macro{AIO\_ALLDONE}] indica che le operazioni di cui si è richiesta la
+\item[\const{AIO\_ALLDONE}] indica che le operazioni di cui si è richiesta la
cancellazione sono state già completate,
-\item[\macro{AIO\_CANCELED}] indica che tutte le operazioni richieste sono
+\item[\const{AIO\_CANCELED}] indica che tutte le operazioni richieste sono
state cancellate,
-\item[\macro{AIO\_NOTCANCELED}] indica che alcune delle operazioni erano in
+\item[\const{AIO\_NOTCANCELED}] indica che alcune delle operazioni erano in
corso e non sono state cancellate.
\end{basedescript}
-Nel caso si abbia \macro{AIO\_NOTCANCELED} occorrerà chiamare
+Nel caso si abbia \const{AIO\_NOTCANCELED} occorrerà chiamare
\func{aio\_error} per determinare quali sono le operazioni effettivamente
cancellate. Le operazioni che non sono state cancellate proseguiranno il loro
corso normale, compreso quanto richiesto riguardo al meccanismo di notifica
completate, e -1 in caso di errore nel qual caso \var{errno} assumerà uno
dei valori:
\begin{errlist}
- \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
+ \item[\errcode{EAGAIN}] Nessuna operazione è stata completata entro
\param{timeout}.
- \item[\macro{ENOSYS}] La funzione non è implementata.
- \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
+ \item[\errcode{ENOSYS}] La funzione non è implementata.
+ \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale.
\end{errlist}
}
\end{prototype}
con delle strutture \var{aiocb} relative ad operazioni effettivamente
richieste, ma può contenere puntatori nulli, che saranno ignorati. In caso si
siano specificati valori non validi l'effetto è indefinito. Un valore
-\macro{NULL} per \param{timout} comporta l'assenza di timeout.
+\val{NULL} per \param{timout} comporta l'assenza di timeout.
Lo standard POSIX.1b infine ha previsto pure una funzione, \func{lio\_listio},
che permette di effettuare la richiesta di una intera lista di operazioni di
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
+ \item[\errcode{EAGAIN}] Nessuna operazione è stata completata entro
\param{timeout}.
- \item[\macro{ENOSYS}] La funzione non è implementata.
- \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
+ \item[\errcode{ENOSYS}] La funzione non è implementata.
+ \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale.
\end{errlist}
}
\end{prototype}
dovrà essere specificato il tipo di operazione tramite il campo
\var{aio\_lio\_opcode}, che può prendere i tre valori:
\begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\macro{LIO\_READ}] si richiede una operazione di lettura.
-\item[\macro{LIO\_WRITE}] si richiede una operazione di scrittura.
-\item[\macro{LIO\_NOP}] non si effettua nessuna operazione.
+\item[\const{LIO\_READ}] si richiede una operazione di lettura.
+\item[\const{LIO\_WRITE}] si richiede una operazione di scrittura.
+\item[\const{LIO\_NOP}] non si effettua nessuna operazione.
\end{basedescript}
l'ultimo valore viene usato quando si ha a che fare con un vettore di
dimensione fissa, per poter specificare solo alcune operazioni, o quando si è
non completate.
L'argomento \param{mode} permette di stabilire il comportamento della
-funzione, se viene specificato il valore \macro{LIO\_WAIT} la funzione si
+funzione, se viene specificato il valore \const{LIO\_WAIT} la funzione si
blocca fino al completamento di tutte le operazioni richieste; se invece si
-specifica \macro{LIO\_NOWAIT} la funzione ritorna immediatamente dopo aver
+specifica \const{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, impostando l'argomento
\param{sig} in maniera analoga a come si fa per il campo \var{aio\_sigevent}
caso di successo, e -1 in caso di errore, nel qual caso \var{errno}
assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EBADF}] si è specificato un file descriptor sbagliato.
- \item[\macro{EINVAL}] si è specificato un valore non valido per uno degli
- argomenti (ad esempio \param{count} è maggiore di \macro{MAX\_IOVEC}).
- \item[\macro{EINTR}] la funzione è stata interrotta da un segnale prima di
+ \item[\errcode{EBADF}] si è specificato un file descriptor sbagliato.
+ \item[\errcode{EINVAL}] si è specificato un valore non valido per uno degli
+ argomenti (ad esempio \param{count} è maggiore di \const{MAX\_IOVEC}).
+ \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale prima di
di avere eseguito una qualunque lettura o scrittura.
- \item[\macro{EAGAIN}] \param{fd} è stato aperto in modalità non bloccante e
+ \item[\errcode{EAGAIN}] \param{fd} è stato aperto in modalità non bloccante e
non ci sono dati in lettura.
- \item[\macro{EOPNOTSUPP}] La coda delle richieste è momentaneamente piena.
+ \item[\errcode{EOPNOTSUPP}] La coda delle richieste è momentaneamente piena.
\end{errlist}
- ed inoltre \macro{EISDIR}, \macro{ENOMEM}, \macro{EFAULT} (se non sono stato
+ ed inoltre \const{EISDIR}, \const{ENOMEM}, \const{EFAULT} (se non sono stato
allocati correttamente i buffer specificati nei campi \func{iov\_base}), più
tutti gli ulteriori errori che potrebbero avere le usuali funzioni di
lettura e scrittura eseguite su \param{fd}.}
Esegue la mappatura in memoria del file \param{fd}.
\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
+ in caso di successo, e \const{MAP\_FAILED} (-1) in caso di errore, nel
qual caso \var{errno} assumerà uno dei 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
- 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 è impostato \macro{PROT\_WRITE} ed \param{fd} è in
+ \item[\errcode{EBADF}] Il file descriptor non è valido, e non si è usato
+ \const{MAP\_ANONYMOUS}.
+ \item[\errcode{EACCES}] Il file descriptor non si riferisce ad un file
+ regolare, o si è richiesto \const{MAP\_PRIVATE} ma \param{fd} non è
+ aperto in lettura, o si è richiesto \const{MAP\_SHARED} e impostato
+ \const{PROT\_WRITE} ed \param{fd} non è aperto in lettura/scrittura, o
+ si è impostato \const{PROT\_WRITE} ed \param{fd} è in
\textit{append-only}.
- \item[\macro{EINVAL}] I valori di \param{start}, \param{length} o
+ \item[\errcode{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 è impostato \macro{MAP\_DENYWRITE} ma \param{fd}
+ \item[\errcode{ETXTBSY}] Si è impostato \const{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
+ \item[\errcode{EAGAIN}] Il file è bloccato, o si è bloccata troppa memoria.
+ \item[\errcode{ENOMEM}] Non c'è memoria o si è superato il limite sul numero
di mappature possibili.
- \item[\macro{ENODEV}] Il filesystem di \param{fd} non supporta il memory
+ \item[\errcode{ENODEV}] Il filesystem di \param{fd} non supporta il memory
mapping.
\end{errlist}
}
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{PROT\_EXEC} & Le pagine possono essere eseguite.\\
- \macro{PROT\_READ} & Le pagine possono essere lette.\\
- \macro{PROT\_WRITE} & Le pagine possono essere scritte.\\
- \macro{PROT\_NONE} & L'accesso alle pagine è vietato.\\
+ \const{PROT\_EXEC} & Le pagine possono essere eseguite.\\
+ \const{PROT\_READ} & Le pagine possono essere lette.\\
+ \const{PROT\_WRITE} & Le pagine possono essere scritte.\\
+ \const{PROT\_NONE} & L'accesso alle pagine è vietato.\\
\hline
\end{tabular}
\caption{Valori dell'argomento \param{prot} di \func{mmap}, relativi alla
sulle pagine di memoria reale, ed le modalità di accesso (lettura,
esecuzione, scrittura); una loro violazione causa quella che si chiama una
\textit{segment violation}, e la relativa emissione del segnale
- \macro{SIGSEGV}.} da applicare al segmento di memoria e deve essere
+ \const{SIGSEGV}.} da applicare al segmento di memoria e deve essere
specificato come maschera binaria ottenuta dall'OR di uno o più dei valori
riportati in \tabref{tab:file_mmap_flag}; il valore specificato deve essere
compatibile con la modalità di accesso con cui si è aperto il file.
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{MAP\_FIXED} & Non permette di restituire un indirizzo diverso
+ \const{MAP\_FIXED} & Non permette di restituire un indirizzo diverso
da \param{start}, se questo non può essere usato
\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
+ \const{MAP\_SHARED} & I cambiamenti sulla memoria mappata vengono
riportati sul file e saranno immediatamente
visibili agli altri processi che mappano lo stesso
file.\footnotemark Il file su disco però non sarà
aggiornato fino alla chiamata di \func{msync} o
\func{unmap}), e solo allora le modifiche saranno
visibili per l'I/O convenzionale. Incompatibile
- con \macro{MAP\_PRIVATE}. \\
- \macro{MAP\_PRIVATE} & I cambiamenti sulla memoria mappata non vengono
+ con \const{MAP\_PRIVATE}. \\
+ \const{MAP\_PRIVATE} & I cambiamenti sulla memoria mappata non vengono
riportati sul file. Ne viene fatta una copia
privata cui solo il processo chiamante ha
accesso. Le modifiche sono mantenute attraverso
salvate su swap in caso di necessità. Non è
specificato se i cambiamenti sul file originale
vengano riportati sulla regione
- mappata. Incompatibile con \macro{MAP\_SHARED}. \\
- \macro{MAP\_DENYWRITE} & In Linux viene ignorato per evitare
+ mappata. Incompatibile con \const{MAP\_SHARED}. \\
+ \const{MAP\_DENYWRITE} & In Linux viene ignorato per evitare
\textit{DoS}\index{DoS} (veniva usato per
segnalare che tentativi di scrittura sul file
- dovevano fallire con \macro{ETXTBUSY}).\\
- \macro{MAP\_EXECUTABLE}& Ignorato. \\
- \macro{MAP\_NORESERVE} & Si usa con \macro{MAP\_PRIVATE}. Non riserva
+ dovevano fallire con \errcode{ETXTBUSY}).\\
+ \const{MAP\_EXECUTABLE}& Ignorato. \\
+ \const{MAP\_NORESERVE} & Si usa con \const{MAP\_PRIVATE}. Non riserva
delle pagine di swap ad uso del meccanismo di
\textit{copy on write}\index{copy on write}
per mantenere le
modifiche fatte alla regione mappata, in
questo caso dopo una scrittura, se non c'è più
memoria disponibile, si ha l'emissione di
- un \macro{SIGSEGV}. \\
- \macro{MAP\_LOCKED} & Se impostato impedisce lo swapping delle pagine
+ un \const{SIGSEGV}. \\
+ \const{MAP\_LOCKED} & Se impostato impedisce lo swapping delle pagine
mappate. \\
- \macro{MAP\_GROWSDOWN} & Usato per gli stack. Indica
+ \const{MAP\_GROWSDOWN} & Usato per gli stack. Indica
che la mappatura deve essere effettuata con gli
indirizzi crescenti verso il basso.\\
- \macro{MAP\_ANONYMOUS} & La mappatura non è associata a nessun file. Gli
+ \const{MAP\_ANONYMOUS} & La mappatura non è associata a nessun file. Gli
argomenti \param{fd} e \param{offset} sono
ignorati.\footnotemark\\
- \macro{MAP\_ANON} & Sinonimo di \macro{MAP\_ANONYMOUS}, deprecato.\\
- \macro{MAP\_FILE} & Valore di compatibilità, deprecato.\\
+ \const{MAP\_ANON} & Sinonimo di \const{MAP\_ANONYMOUS}, deprecato.\\
+ \const{MAP\_FILE} & Valore di compatibilità, deprecato.\\
\hline
\end{tabular}
\caption{Valori possibili dell'argomento \param{flag} di \func{mmap}.}
\footnotetext{Dato che tutti faranno riferimento alle stesse pagine di
memoria.}
-\footnotetext{L'uso di questo flag con \macro{MAP\_SHARED} è
+\footnotetext{L'uso di questo flag con \const{MAP\_SHARED} è
stato implementato in Linux a partire dai kernel della serie 2.4.x.}
Gli effetti dell'accesso ad una zona di memoria mappata su file possono essere
tutto quanto è comunque basato sul basato sul meccanismo della memoria
virtuale. Questo comporta allora una serie di conseguenze. La più ovvia è che
se si cerca di scrivere su una zona mappata in sola lettura si avrà
-l'emissione di un segnale di violazione di accesso (\macro{SIGSEGV}), dato che
+l'emissione di un segnale di violazione di accesso (\const{SIGSEGV}), dato che
i permessi sul segmento di memoria relativo non consentono questo tipo di
accesso.
In questo caso è possibile accedere a quella zona di memoria che eccede le
-dimensioni specificate da \param{lenght}, senza ottenere un \macro{SIGSEGV}
+dimensioni specificate da \param{lenght}, senza ottenere un \const{SIGSEGV}
poiché essa è presente nello spazio di indirizzi del processo, anche se non è
mappata sul file. Il comportamento del sistema è quello di restituire un
valore nullo per quanto viene letto, e di non riportare su file quanto viene
In questa situazione, per la sezione di pagina parzialmente coperta dal
contenuto del file, vale esattamente quanto visto in precedenza; invece per la
parte che eccede, fino alle dimensioni date da \param{length}, l'accesso non
-sarà più possibile, ma il segnale emesso non sarà \macro{SIGSEGV}, ma
-\macro{SIGBUS}, come illustrato in \figref{fig:file_mmap_exceed}.
+sarà più possibile, ma il segnale emesso non sarà \const{SIGSEGV}, ma
+\const{SIGBUS}, come illustrato in \figref{fig:file_mmap_exceed}.
Non tutti i file possono venire mappati in memoria, dato che, come illustrato
in \figref{fig:file_mmap_layout}, la mappatura introduce una corrispondenza
Dato che passando attraverso una \func{fork} lo spazio di indirizzi viene
copiato integralmente, i file mappati in memoria verranno ereditati in maniera
trasparente dal processo figlio, mantenendo gli stessi attributi avuti nel
-padre; così se si è usato \macro{MAP\_SHARED} padre e figlio accederanno allo
-stesso file in maniera condivisa, mentre se si è usato \macro{MAP\_PRIVATE}
+padre; così se si è usato \const{MAP\_SHARED} padre e figlio accederanno allo
+stesso file in maniera condivisa, mentre se si è usato \const{MAP\_PRIVATE}
ciascuno di essi manterrà una sua versione privata indipendente. Non c'è
invece nessun passaggio attraverso una \func{exec}, dato che quest'ultima
sostituisce tutto lo spazio degli indirizzi di un processo con quello di un
una pagina mappata su un file aggiorna questo tempo. I valori di
\var{st\_ctime} e \var{st\_mtime} possono venir cambiati solo quando si è
consentita la scrittura sul file (cioè per un file mappato con
-\macro{PROT\_WRITE} e \macro{MAP\_SHARED}) e sono aggiornati dopo la scrittura
+\const{PROT\_WRITE} e \const{MAP\_SHARED}) e sono aggiornati dopo la scrittura
o in corrispondenza di una eventuale \func{msync}.
Dato per i file mappati in memoria le operazioni di I/O sono gestite
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
errore nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EINVAL}] O \param{start} non è multiplo di \macro{PAGESIZE},
+ \item[\errcode{EINVAL}] O \param{start} non è multiplo di \const{PAGESIZE},
o si è specificato un valore non valido per \param{flags}.
- \item[\macro{EFAULT}] L'intervallo specificato non ricade in una zona
+ \item[\errcode{EFAULT}] L'intervallo specificato non ricade in una zona
precedentemente mappata.
\end{errlist}
}
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{MS\_ASYNC} & Richiede la sincronizzazione.\\
- \macro{MS\_SYNC} & Attende che la sincronizzazione si eseguita.\\
- \macro{MS\_INVALIDATE}& Richiede che le altre mappature dello stesso file
+ \const{MS\_ASYNC} & Richiede la sincronizzazione.\\
+ \const{MS\_SYNC} & Attende che la sincronizzazione si eseguita.\\
+ \const{MS\_INVALIDATE}& Richiede che le altre mappature dello stesso file
siano invalidate.\\
\hline
\end{tabular}
L'argomento \param{flag} è specificato come maschera binaria composta da un OR
dei valori riportati in \tabref{tab:file_mmap_rsync}, di questi però
-\macro{MS\_ASYNC} e \macro{MS\_SYNC} sono incompatibili; con il primo valore
+\const{MS\_ASYNC} e \const{MS\_SYNC} sono incompatibili; con il primo valore
infatti la funzione si limita ad inoltrare la richiesta di sincronizzazione al
meccanismo della memoria virtuale, ritornando subito, mentre con il secondo
attende che la sincronizzazione sia stata effettivamente eseguita. Il terzo
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
errore nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EINVAL}] L'intervallo specificato non ricade in una zona
+ \item[\errcode{EINVAL}] L'intervallo specificato non ricade in una zona
precedentemente mappata.
\end{errlist}
}
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EWOULDBLOCK}] Il file ha già un blocco attivo, e si è
- specificato \macro{LOCK\_NB}.
+ \item[\errcode{EWOULDBLOCK}] Il file ha già un blocco attivo, e si è
+ specificato \const{LOCK\_NB}.
\end{errlist}
}
\end{prototype}
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{LOCK\_SH} & Asserisce uno \textit{shared lock} sul file.\\
- \macro{LOCK\_EX} & Asserisce un \textit{esclusive lock} sul file.\\
- \macro{LOCK\_UN} & Rilascia il \textit{file lock}.\\
- \macro{LOCK\_NB} & Impedisce che la funzione si blocchi nella
+ \const{LOCK\_SH} & Asserisce uno \textit{shared lock} sul file.\\
+ \const{LOCK\_EX} & Asserisce un \textit{esclusive lock} sul file.\\
+ \const{LOCK\_UN} & Rilascia il \textit{file lock}.\\
+ \const{LOCK\_NB} & Impedisce che la funzione si blocchi nella
richiesta di un \textit{file lock}.\\
\hline
\end{tabular}
\label{tab:file_flock_operation}
\end{table}
-I primi due valori, \macro{LOCK\_SH} e \macro{LOCK\_EX} permettono di
+I primi due valori, \const{LOCK\_SH} e \const{LOCK\_EX} permettono di
richiedere un \textit{file lock}, ed ovviamente devono essere usati in maniera
-alternativa. Se si specifica anche \macro{LOCK\_NB} la funzione non si
+alternativa. Se si specifica anche \const{LOCK\_NB} la funzione non si
bloccherà qualora il lock non possa essere acquisito, ma ritornerà subito con
-un errore di \macro{EWOULDBLOCK}. Per rilasciare un lock si dovrà invece usare
-\macro{LOCK\_UN}.
+un errore di \errcode{EWOULDBLOCK}. Per rilasciare un lock si dovrà invece
+usare \const{LOCK\_UN}.
La semantica del file locking di BSD è diversa da quella del file locking
POSIX, in particolare per quanto riguarda il comportamento dei lock nei
\var{i\_flock} della struttura \var{inode} (per le definizioni esatte si
faccia riferimento al file \file{fs.h} nei sorgenti del kernel). Un bit del
campo \var{fl\_flags} di specifica se si tratta di un lock in semantica BSD
- (\macro{FL\_FLOCK}) o POSIX (\macro{FL\_POSIX}).} dato che questo è l'unico
+ (\const{FL\_FLOCK}) o POSIX (\const{FL\_POSIX}).} dato che questo è l'unico
riferimento in comune che possono avere due processi diversi che aprono lo
stesso file.
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EACCES}] L'operazione è proibita per la presenza di
+ \item[\errcode{EACCES}] L'operazione è proibita per la presenza di
\textit{file lock} da parte di altri processi.
- \item[\macro{ENOLCK}] Il sistema non ha le risorse per il locking: ci sono
- troppi segmenti di lock aperti, si è esaurita la tabella dei lock, o il
- protocollo per il locking remoto è fallito.
- \item[\macro{EDEADLK}] Si è richiesto un lock su una regione bloccata da
+ \item[\errcode{ENOLCK}] Il sistema non ha le risorse per il locking: ci
+ sono troppi segmenti di lock aperti, si è esaurita la tabella dei lock,
+ o il protocollo per il locking remoto è fallito.
+ \item[\errcode{EDEADLK}] Si è richiesto un lock su una regione bloccata da
un altro processo che è a sua volta in attesa dello sblocco di un lock
mantenuto dal processo corrente; si avrebbe pertanto un
\textit{deadlock}. Non è garantito che il sistema riconosca sempre
questa situazione.
- \item[\macro{EINTR}] La funzione è stata interrotta da un segnale prima di
- poter acquisire un lock.
+ \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale prima
+ di poter acquisire un lock.
\end{errlist}
- ed inoltre \macro{EBADF}, \macro{EFAULT}.
+ ed inoltre \const{EBADF}, \const{EFAULT}.
}
\end{prototype}
lunghezza della sezione e infine \var{l\_whence} imposta il riferimento da cui
contare \var{l\_start}. Il valore di \var{l\_whence} segue la stessa semantica
dell'omonimo argomento di \func{lseek}, coi tre possibili valori
-\macro{SEEK\_SET}, \macro{SEEK\_CUR} e \macro{SEEK\_END}, (si vedano le
+\const{SEEK\_SET}, \const{SEEK\_CUR} e \const{SEEK\_END}, (si vedano le
relative descrizioni in \secref{sec:file_lseek}).
Si tenga presente che un lock può essere richiesto anche per una regione al di
\tabref{tab:file_flock_type}, che permettono di richiedere rispettivamente uno
\textit{shared lock}, un \textit{esclusive lock}, e la rimozione di un lock
precedentemente acquisito. Infine il campo \var{l\_pid} viene usato solo in
-caso di lettura, quando si chiama \func{fcntl} con \macro{F\_GETLK}, e riporta
+caso di lettura, quando si chiama \func{fcntl} con \const{F\_GETLK}, e riporta
il \acr{pid} del processo che detiene il lock.
\begin{table}[htb]
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{F\_RDLCK} & Richiede un blocco condiviso (\textit{read lock}).\\
- \macro{F\_WRLCK} & Richiede un blocco esclusivo (\textit{write lock}).\\
- \macro{F\_UNLCK} & Richiede l'eliminazione di un file lock.\\
+ \const{F\_RDLCK} & Richiede un blocco condiviso (\textit{read lock}).\\
+ \const{F\_WRLCK} & Richiede un blocco esclusivo (\textit{write lock}).\\
+ \const{F\_UNLCK} & Richiede l'eliminazione di un file lock.\\
\hline
\end{tabular}
\caption{Valori possibili per il campo \var{l\_type} di \func{flock}.}
\param{cmd} che, come già riportato in \secref{sec:file_fcntl}, specifica
l'azione da compiere; i valori relativi al file locking sono tre:
\begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\macro{F\_GETLK}] verifica se il file lock specificato dalla struttura
+\item[\const{F\_GETLK}] verifica se il file lock specificato dalla struttura
puntata da \param{lock} può essere acquisito: in caso negativo sovrascrive
la struttura \param{flock} con i valori relativi al lock già esistente che
ne blocca l'acquisizione, altrimenti si limita a impostarne il campo
- \var{l\_type} con il valore \macro{F\_UNLCK}.
-\item[\macro{F\_SETLK}] se il campo \var{l\_type} della struttura puntata da
- \param{lock} è \macro{F\_RDLCK} o \macro{F\_WRLCK} richiede il
- corrispondente file lock, se è \macro{F\_UNLCK} lo rilascia. Nel caso la
+ \var{l\_type} con il valore \const{F\_UNLCK}.
+\item[\const{F\_SETLK}] se il campo \var{l\_type} della struttura puntata da
+ \param{lock} è \const{F\_RDLCK} o \const{F\_WRLCK} richiede il
+ corrispondente file lock, se è \const{F\_UNLCK} lo rilascia. Nel caso la
richiesta non possa essere soddisfatta a causa di un lock preesistente la
- funzione ritorna immediatamente con un errore di \macro{EACCES} o di
- \macro{EAGAIN}.
-\item[\macro{F\_SETLKW}] è identica a \macro{F\_SETLK}, ma se la richiesta di
+ funzione ritorna immediatamente con un errore di \errcode{EACCES} o di
+ \errcode{EAGAIN}.
+\item[\const{F\_SETLKW}] è identica a \const{F\_SETLK}, ma se la richiesta di
non può essere soddisfatta per la presenza di un altro lock, mette il
processo in stato di attesa fintanto che il lock precedente non viene
rilasciato. Se l'attesa viene interrotta da un segnale la funzione ritorna
- con un errore di \macro{EINTR}.
+ con un errore di \errcode{EINTR}.
\end{basedescript}
-Si noti che per quanto detto il comando \macro{F\_GETLK} non serve a rilevare
+Si noti che per quanto detto il comando \const{F\_GETLK} non serve a rilevare
una presenza generica di lock su un file, perché se ne esistono altri
compatibili con quello richiesto, la funzione ritorna comunque impostando
-\var{l\_type} a \macro{F\_UNLCK}. Inoltre a seconda del valore di
+\var{l\_type} a \const{F\_UNLCK}. Inoltre a seconda del valore di
\var{l\_type} si potrà controllare o l'esistenza di un qualunque tipo di lock
-(se è \macro{F\_WRLCK}) o di write lock (se è \macro{F\_RDLCK}). Si consideri
+(se è \const{F\_WRLCK}) o di write lock (se è \const{F\_RDLCK}). Si consideri
poi che può esserci più di un lock che impedisce l'acquisizione di quello
richiesto (basta che le regioni si sovrappongano), ma la funzione ne riporterà
-sempre soltanto uno, impostando \var{l\_whence} a \macro{SEEK\_SET} ed i
+sempre soltanto uno, impostando \var{l\_whence} a \const{SEEK\_SET} ed i
valori \var{l\_start} e \var{l\_len} per indicare quale è la regione bloccata.
Infine si tenga presente che effettuare un controllo con il comando
-\macro{F\_GETLK} e poi tentare l'acquisizione con \macro{F\_SETLK} non è una
+\const{F\_GETLK} e poi tentare l'acquisizione con \const{F\_SETLK} non è una
operazione atomica (un altro processo potrebbe acquisire un lock fra le due
chiamate) per cui si deve sempre verificare il codice di ritorno di
\func{fcntl}\footnote{controllare il codice di ritorno delle funzioni invocate
è comunque una buona norma di programmazione, che permette di evitare un
sacco di errori difficili da tracciare proprio perché non vengono rilevati.}
-quando la si invoca con \macro{F\_SETLK}, per controllare che il lock sia
+quando la si invoca con \const{F\_SETLK}, per controllare che il lock sia
stato effettivamente acquisito.
\begin{figure}[htb]
porta ad un \textit{deadlock}\index{deadlock}, dato che a quel punto anche il
processo 2 si bloccherebbe, e niente potrebbe sbloccare l'altro processo. Per
questo motivo il kernel si incarica di rilevare situazioni di questo tipo, ed
-impedirle restituendo un errore di \macro{EDEADLK} alla funzione che cerca di
+impedirle restituendo un errore di \errcode{EDEADLK} alla funzione che cerca di
acquisire un lock che porterebbe ad un \textit{deadlock}.
\begin{figure}[!bht]
\var{fl\_pid}, la sezione di file che viene bloccata grazie ai campi
\var{fl\_start} e \var{fl\_end}. La struttura è comunque la stessa, solo
che in questo caso nel campo \var{fl\_flags} è impostato il bit
- \macro{FL\_POSIX} ed il campo \var{fl\_file} non viene usato.} il lock è
+ \const{FL\_POSIX} ed il campo \var{fl\_file} non viene usato.} il lock è
sempre associato all'inode, solo che in questo caso la titolarità non viene
identificata con il riferimento ad una voce nella file table, ma con il valore
del \acr{pid} del processo.
Quando si richiede un lock il kernel effettua una scansione di tutti i lock
presenti sul file\footnote{scandisce cioè la linked list delle strutture
\var{file\_lock}, scartando automaticamente quelle per cui \var{fl\_flags}
- non è \macro{FL\_POSIX}, così che le due interfacce restano ben separate.}
+ non è \const{FL\_POSIX}, così che le due interfacce restano ben separate.}
per verificare se la regione richiesta non si sovrappone ad una già bloccata,
in caso affermativo decide in base al tipo di lock, in caso negativo il nuovo
lock viene comunque acquisito ed aggiunto alla lista.
comportamento dipende dalla semantica scelta; nel caso sia BSD occorre
reimpostare il valore di \var{cmd} per l'uso con \func{flock}; infatti il
valore preimpostato fa riferimento alla semantica POSIX e vale rispettivamente
-\macro{F\_SETLKW} o \macro{F\_SETLK} a seconda che si sia impostato o meno la
+\const{F\_SETLKW} o \const{F\_SETLK} a seconda che si sia impostato o meno la
modalità bloccante.
Nel caso si sia scelta la semantica BSD (\texttt{\small 25--34}) prima si
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EWOULDBLOCK}] Non è possibile acquisire il lock, e si è
- selezionato \macro{LOCK\_NB}, oppure l'operazione è proibita perché il
+ \item[\errcode{EWOULDBLOCK}] Non è possibile acquisire il lock, e si è
+ selezionato \const{LOCK\_NB}, oppure l'operazione è proibita perché il
file è mappato in memoria.
- \item[\macro{ENOLCK}] Il sistema non ha le risorse per il locking: ci sono
- troppi segmenti di lock aperti, si è esaurita la tabella dei lock.
+ \item[\errcode{ENOLCK}] Il sistema non ha le risorse per il locking: ci
+ sono troppi segmenti di lock aperti, si è esaurita la tabella dei lock.
\end{errlist}
- ed inoltre \macro{EBADF}, \macro{EINVAL}.
+ ed inoltre \const{EBADF}, \const{EINVAL}.
}
\end{prototype}
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{LOCK\_SH}& Richiede uno \textit{shared lock}. Più processi possono
+ \const{LOCK\_SH}& Richiede uno \textit{shared lock}. Più processi possono
mantenere un lock condiviso sullo stesso file.\\
- \macro{LOCK\_EX}& Richiede un \textit{exclusive lock}. Un solo processo
+ \const{LOCK\_EX}& Richiede un \textit{exclusive lock}. Un solo processo
alla volta può mantenere un lock esclusivo su un file. \\
- \macro{LOCK\_UN}& Sblocca il file.\\
- \macro{LOCK\_NB}& Non blocca la funzione quando il lock non è disponibile,
+ \const{LOCK\_UN}& Sblocca il file.\\
+ \const{LOCK\_NB}& Non blocca la funzione quando il lock non è disponibile,
si specifica sempre insieme ad una delle altre operazioni
con un OR aritmetico dei valori.\\
\hline
\end{table}
Qualora il lock non possa essere acquisito, a meno di non aver specificato
-\macro{LOCK\_NB}, la funzione si blocca fino alla disponibilità dello stesso.
+\const{LOCK\_NB}, la funzione si blocca fino alla disponibilità dello stesso.
Dato che la funzione è implementata utilizzando \func{fcntl} la semantica
delle operazioni è la stessa di quest'ultima (pertanto la funzione non è
affatto equivalente a \func{flock}).
Questo significa che in caso di read lock la lettura dal file potrà avvenire
normalmente con \func{read}, mentre una \func{write} si bloccherà fino al
-rilascio del lock, a meno di non aver aperto il file con \macro{O\_NONBLOCK},
-nel qual caso essa ritornerà immediatamente con un errore di \macro{EAGAIN}.
+rilascio del lock, a meno di non aver aperto il file con \const{O\_NONBLOCK},
+nel qual caso essa ritornerà immediatamente con un errore di \errcode{EAGAIN}.
Se invece si è acquisito un write lock tutti i tentativi di leggere o scrivere
sulla regione del file bloccata fermeranno il processo fino al rilascio del
-lock, a meno che il file non sia stato aperto con \macro{O\_NONBLOCK}, nel
+lock, a meno che il file non sia stato aperto con \const{O\_NONBLOCK}, nel
qual caso di nuovo si otterrà un ritorno immediato con l'errore di
-\macro{EAGAIN}.
+\errcode{EAGAIN}.
Infine occorre ricordare che le funzioni di lettura e scrittura non sono le
sole ad operare sui contenuti di un file, e che sia \func{creat} che
-\func{open} (quando chiamata con \macro{O\_TRUNC}) effettuano dei cambiamenti,
+\func{open} (quando chiamata con \const{O\_TRUNC}) effettuano dei cambiamenti,
così come \func{truncate}, riducendone le dimensioni (a zero nei primi due
casi, a quanto specificato nel secondo). Queste operazioni sono assimilate a
degli accessi in scrittura e pertanto non potranno essere eseguite (fallendo
-con un errore di \macro{EAGAIN}) su un file su cui sia presente un qualunque
+con un errore di \errcode{EAGAIN}) su un file su cui sia presente un qualunque
lock (le prime due sempre, la terza solo nel caso che la riduzione delle
dimensioni del file vada a sovrapporsi ad una regione bloccata).
L'ultimo aspetto della interazione del \textit{mandatory locking} con le
funzioni di accesso ai file è quello relativo ai file mappati in memoria (che
abbiamo trattato in \secref{sec:file_memory_map}); anche in tal caso infatti,
-quando si esegue la mappatura con l'opzione \macro{MAP\_SHARED}, si ha un
+quando si esegue la mappatura con l'opzione \const{MAP\_SHARED}, si ha un
accesso al contenuto del file. Lo standard SVID prevede che sia impossibile
eseguire il memory mapping di un file su cui sono presenti dei
lock\footnote{alcuni sistemi, come HP-UX, sono ancora più restrittivi e lo
implementativa\footnote{per i dettagli si possono leggere le note relative
all'implementazione, mantenute insime ai sorgenti del kernel nel file
\file{Documentation/mandatory.txt}.} di seguire questo comportamento
-soltanto quando si chiama \func{mmap} con l'opzione \macro{MAP\_SHARED} (nel
-qual caso la funzione fallisce con il solito \macro{EAGAIN}) che comporta la
+soltanto quando si chiama \func{mmap} con l'opzione \const{MAP\_SHARED} (nel
+qual caso la funzione fallisce con il solito \errcode{EAGAIN}) che comporta la
possibilità di modificare il file.
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
+ \item[\errcode{EXDEV}] \param{oldpath} e \param{newpath} non sono sullo
stesso filesystem.
- \item[\macro{EPERM}] il filesystem che contiene \var{oldpath} e
- \macro{newpath} non supporta i link diretti o è una directory.
- \item[\macro{EEXIST}] un file (o una directory) con quel nome esiste di
+ \item[\errcode{EPERM}] il filesystem che contiene \param{oldpath} e
+ \param{newpath} non supporta i link diretti o è una directory.
+ \item[\errcode{EEXIST}] un file (o una directory) con quel nome esiste di
già.
- \item[\macro{EMLINK}] ci sono troppi link al file \var{oldpath} (il
- numero massimo è specificato dalla variabile \macro{LINK\_MAX}, vedi
+ \item[\errcode{EMLINK}] ci sono troppi link al file \param{oldpath} (il
+ numero massimo è specificato dalla variabile \const{LINK\_MAX}, vedi
\secref{sec:sys_limits}).
\end{errlist}
- ed inoltre \macro{EACCES}, \macro{ENAMETOOLONG}, \macro{ENOTDIR},
- \macro{EFAULT}, \macro{ENOMEM}, \macro{EROFS}, \macro{ELOOP},
- \macro{ENOSPC}, \macro{EIO}.}
+ ed inoltre \const{EACCES}, \const{ENAMETOOLONG}, \const{ENOTDIR},
+ \const{EFAULT}, \const{ENOMEM}, \const{EROFS}, \const{ELOOP},
+ \const{ENOSPC}, \const{EIO}.}
\end{prototype}
La creazione di un nuovo collegamento diretto non copia il contenuto del file,
simbolici che possono fornire la stessa funzionalità senza questi problemi,
nei filesystem usati in Linux questa caratteristica è stata completamente
disabilitata, e al tentativo di creare un link diretto ad una directory la
-funzione restituisce l'errore \macro{EPERM}.
+funzione restituisce l'errore \errcode{EPERM}.
La rimozione di un file (o più precisamente della voce che lo referenzia
all'interno di una directory) si effettua con la funzione \func{unlink}; il
errore, nel qual caso il file non viene toccato. La variabile
\var{errno} viene impostata secondo i seguenti codici di errore:
\begin{errlist}
- \item[\macro{EISDIR}] \var{pathname} si riferisce ad una directory
+ \item[\errcode{EISDIR}] \var{pathname} si riferisce ad una directory
(valore specifico ritornato da Linux che non consente l'uso di
\var{unlink} con le directory, e non conforme allo standard POSIX, che
- prescrive invece l'uso di \macro{EPERM} in caso l'operazione non sia
+ prescrive invece l'uso di \errcode{EPERM} in caso l'operazione non sia
consentita o il processo non abbia privilegi sufficienti).
- \item[\macro{EROFS}] \var{pathname} è su un filesystem montato in sola
+ \item[\errcode{EROFS}] \var{pathname} è su un filesystem montato in sola
lettura.
- \item[\macro{EISDIR}] \var{pathname} fa riferimento a una directory.
+ \item[\errcode{EISDIR}] \var{pathname} fa riferimento a una directory.
\end{errlist}
- ed inoltre: \macro{EACCES}, \macro{EFAULT}, \macro{ENOENT}, \macro{ENOTDIR},
- \macro{ENOMEM}, \macro{EROFS}, \macro{ELOOP}, \macro{EIO}.}
+ ed inoltre: \const{EACCES}, \const{EFAULT}, \const{ENOENT}, \const{ENOTDIR},
+ \const{ENOMEM}, \const{EROFS}, \const{ELOOP}, \const{EIO}.}
\end{prototype}
Per cancellare una voce in una directory è necessario avere il permesso di
errore, nel qual caso il file non viene toccato. La variabile
\var{errno} viene impostata secondo i seguenti codici di errore:
\begin{errlist}
- \item[\macro{EISDIR}] \var{newpath} è una directory mentre \var{oldpath} non
+ \item[\errcode{EISDIR}] \var{newpath} è una directory mentre \var{oldpath} non
è una directory.
- \item[\macro{EXDEV}] \var{oldpath} e \var{newpath} non sono sullo stesso
+ \item[\errcode{EXDEV}] \var{oldpath} e \var{newpath} non sono sullo stesso
filesystem.
- \item[\macro{ENOTEMPTY}] \var{newpath} è una directory già esistente e non
+ \item[\errcode{ENOTEMPTY}] \var{newpath} è una directory già esistente e non
vuota.
- \item[\macro{EBUSY}] o \var{oldpath} o \var{newpath} sono in uso da parte di
- qualche processo (come directory di lavoro o come radice) o del sistema
+ \item[\errcode{EBUSY}] o \var{oldpath} o \var{newpath} sono in uso da parte
+ di qualche processo (come directory di lavoro o come radice) o del sistema
(come mount point).
- \item[\macro{EINVAL}] \var{newpath} contiene un prefisso di \var{oldpath} o
+ \item[\errcode{EINVAL}] \var{newpath} contiene un prefisso di \var{oldpath} o
più in generale si è cercato di creare una directory come sottodirectory
di se stessa.
- \item[\macro{ENOTDIR}] Uno dei componenti dei pathname non è una directory o
- \var{oldpath} è una directory e \var{newpath} esiste e non è una
+ \item[\errcode{ENOTDIR}] Uno dei componenti dei pathname non è una directory
+ o \var{oldpath} è una directory e \var{newpath} esiste e non è una
directory.
\end{errlist}
- ed inoltre \macro{EACCESS}, \macro{EPERM}, \macro{EMLINK}, \macro{ENOENT},
- \macro{ENOMEM}, \macro{EROFS}, \macro{ELOOP} e \macro{ENOSPC}.}
+ ed inoltre \const{EACCESS}, \const{EPERM}, \const{EMLINK}, \const{ENOENT},
+ \const{ENOMEM}, \const{EROFS}, \const{ELOOP} e \const{ENOSPC}.}
\end{prototype}
Il comportamento della funzione è diverso a seconda che si voglia rinominare
un file o una directory; se ci riferisce a un file allora \var{newpath}, se
esiste, non deve essere una directory (altrimenti si ha l'errore
-\macro{EISDIR}). Nel caso \var{newpath} indichi un file esistente questo viene
-cancellato e rimpiazzato (atomicamente).
+\errcode{EISDIR}). Nel caso \var{newpath} indichi un file esistente questo
+viene cancellato e rimpiazzato (atomicamente).
Se \var{oldpath} è una directory allora \var{newpath}, se esiste, deve essere
-una directory vuota, altrimenti si avranno gli errori \macro{ENOTDIR} (se non
-è una directory) o \macro{ENOTEMPTY} (se non è vuota). Chiaramente
+una directory vuota, altrimenti si avranno gli errori \errcode{ENOTDIR} (se
+non è una directory) o \errcode{ENOTEMPTY} (se non è vuota). Chiaramente
\var{newpath} non può contenere \var{oldpath} altrimenti si avrà un errore
-\macro{EINVAL}.
+\errcode{EINVAL}.
Se \var{oldpath} si riferisce a un link simbolico questo sarà rinominato; se
\var{newpath} è un link simbolico verrà cancellato come qualunque altro file.
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
errore, nel qual caso la variabile \var{errno} assumerà i valori:
\begin{errlist}
- \item[\macro{EPERM}] il filesystem che contiene \param{newpath} non supporta
- i link simbolici.
- \item[\macro{ENOENT}] una componente di \param{newpath} non esiste o
+ \item[\errcode{EPERM}] il filesystem che contiene \param{newpath} non
+ supporta i link simbolici.
+ \item[\errcode{ENOENT}] una componente di \param{newpath} non esiste o
\param{oldpath} è una stringa vuota.
- \item[\macro{EEXIST}] esiste già un file \param{newpath}.
- \item[\macro{EROFS}] \param{newpath} è su un filesystem montato in sola
+ \item[\errcode{EEXIST}] esiste già un file \param{newpath}.
+ \item[\errcode{EROFS}] \param{newpath} è su un filesystem montato in sola
lettura.
\end{errlist}
- ed inoltre \macro{EFAULT}, \macro{EACCES}, \macro{ENAMETOOLONG},
- \macro{ENOTDIR}, \macro{ENOMEM}, \macro{ELOOP}, \macro{ENOSPC} e
- \macro{EIO}.}
+ ed inoltre \const{EFAULT}, \const{EACCES}, \const{ENAMETOOLONG},
+ \const{ENOTDIR}, \const{ENOMEM}, \const{ELOOP}, \const{ENOSPC} e
+ \const{EIO}.}
\end{prototype}
Si tenga presente che la funzione non effettua nessun controllo sull'esistenza
\var{buff} o -1 per un errore, nel qual caso la variabile
\var{errno} assumerà i valori:
\begin{errlist}
- \item[\macro{EINVAL}] \param{path} non è un link simbolico o \param{size}
+ \item[\errcode{EINVAL}] \param{path} non è un link simbolico o \param{size}
non è positiva.
\end{errlist}
- ed inoltre \macro{ENOTDIR}, \macro{ENAMETOOLONG}, \macro{ENOENT},
- \macro{EACCES}, \macro{ELOOP}, \macro{EIO}, \macro{EFAULT} e
- \macro{ENOMEM}.}
+ ed inoltre \const{ENOTDIR}, \const{ENAMETOOLONG}, \const{ENOENT},
+ \const{EACCES}, \const{ELOOP}, \const{EIO}, \const{EFAULT} e
+ \const{ENOMEM}.}
\end{prototype}
La funzione apre il link simbolico, ne legge il contenuto, lo scrive nel
Per questo motivo il kernel e le librerie prevedono che nella risoluzione di
un pathname possano essere seguiti un numero limitato di link simbolici, il
-cui valore limite è specificato dalla costante \macro{MAXSYMLINKS}. Qualora
+cui valore limite è specificato dalla costante \const{MAXSYMLINKS}. Qualora
questo limite venga superato viene generato un errore ed \var{errno} viene
-impostata al valore \macro{ELOOP}.
+impostata al valore \errcode{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
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
errore, nel qual caso \var{errno} assumerà i valori:
\begin{errlist}
- \item[\macro{EEXIST}] Un file (o una directory) con quel nome esiste di già.
- \item[\macro{EACCESS}]
+ \item[\errcode{EEXIST}] Un file (o una directory) con quel nome esiste di già.
+ \item[\errcode{EACCESS}]
Non c'è il permesso di scrittura per la directory in cui si vuole inserire
la nuova directory.
- \item[\macro{EMLINK}] La directory in cui si vuole creare la nuova directory
+ \item[\errcode{EMLINK}] La directory in cui si vuole creare la nuova directory
contiene troppi file. Sotto Linux questo normalmente non avviene perché il
filesystem standard consente la creazione di un numero di file maggiore di
quelli che possono essere contenuti nel disco, ma potendo avere a che
fare anche con filesystem di altri sistemi questo errore può presentarsi.
- \item[\macro{ENOSPC}] Non c'è abbastanza spazio sul file system per creare
+ \item[\errcode{ENOSPC}] Non c'è abbastanza spazio sul file system per creare
la nuova directory o si è esaurita la quota disco dell'utente.
\end{errlist}
- ed inoltre anche \macro{EPERM}, \macro{EFAULT}, \macro{ENAMETOOLONG},
- \macro{ENOENT}, \macro{ENOTDIR}, \macro{ENOMEM}, \macro{ELOOP},
- \macro{EROFS}.}
+ ed inoltre anche \const{EPERM}, \const{EFAULT}, \const{ENAMETOOLONG},
+ \const{ENOENT}, \const{ENOTDIR}, \const{ENOMEM}, \const{ELOOP},
+ \const{EROFS}.}
\end{prototype}
La funzione crea una nuova directory vuota (che contiene solo le due voci
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
errore, nel qual caso \var{errno} assumerà i valori:
\begin{errlist}
- \item[\macro{EPERM}] Il filesystem non supporta la cancellazione di
+ \item[\errcode{EPERM}] Il filesystem non supporta la cancellazione di
directory, oppure la directory che contiene \var{dirname} ha lo sticky bit
impostato e l'userid effettivo del processo non corrisponde al
proprietario della directory.
- \item[\macro{EACCESS}] Non c'è il permesso di scrittura per la directory che
+ \item[\errcode{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
\var{dirname}.
- \item[\macro{EBUSY}] La directory specificata è la directory di lavoro o la
+ \item[\errcode{EBUSY}] La directory specificata è la directory di lavoro o la
radice di qualche processo.
- \item[\macro{ENOTEMPTY}] La directory non è vuota.
+ \item[\errcode{ENOTEMPTY}] La directory non è vuota.
\end{errlist}
- ed inoltre anche \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
- \macro{ENOTDIR}, \macro{ENOMEM}, \macro{ELOOP}, \macro{EROFS}.}
+ ed inoltre anche \const{EFAULT}, \const{ENAMETOOLONG}, \const{ENOENT},
+ \const{ENOTDIR}, \const{ENOMEM}, \const{ELOOP}, \const{EROFS}.}
\end{prototype}
La modalità con cui avviene la cancellazione è analoga a quella di
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
errore, nel qual caso \var{errno} assumerà i valori:
\begin{errlist}
- \item[\macro{EPERM}] Non si hanno privilegi sufficienti a creare l'inode, o
+ \item[\errcode{EPERM}] Non si hanno privilegi sufficienti a creare l'inode, o
il filesystem su cui si è cercato di creare \func{pathname} non supporta
l'operazione.
- \item[\macro{EINVAL}] Il valore di \var{mode} non indica un file, una fifo o
- un dipositivo.
- \item[\macro{EEXIST}] \param{pathname} esiste già o è un link simbolico.
+ \item[\errcode{EINVAL}] Il valore di \var{mode} non indica un file, una fifo
+ o un dipositivo.
+ \item[\errcode{EEXIST}] \param{pathname} esiste già o è un link simbolico.
\end{errlist}
- ed inoltre anche \macro{EFAULT}, \macro{EACCESS}, \macro{ENAMETOOLONG},
- \macro{ENOENT}, \macro{ENOTDIR}, \macro{ENOMEM}, \macro{ELOOP},
- \macro{ENOSPC}, \macro{EROFS}.}
+ ed inoltre anche \const{EFAULT}, \const{EACCESS}, \const{ENAMETOOLONG},
+ \const{ENOENT}, \const{ENOTDIR}, \const{ENOMEM}, \const{ELOOP},
+ \const{ENOSPC}, \const{EROFS}.}
\end{functions}
La funzione permette di creare un file speciale, ma si può usare anche per
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 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
+Per il tipo di file può essere specificato solo uno fra: \const{S\_IFREG} per
+un file regolare (che sarà creato vuoto), \const{S\_IFBLK} per un device a
+blocchi, \const{S\_IFCHR} per un device a caratteri e \const{S\_IFIFO} per una
+fifo. Un valore diverso comporterà l'errore \errcode{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.
\funcdecl{int mkfifo(const char *pathname, mode\_t mode)} Crea una fifo.
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
- errore, nel qual caso \var{errno} assumerà i valori \macro{EACCESS},
- \macro{EEXIST}, \macro{ENAMETOOLONG}, \macro{ENOENT}, \macro{ENOSPC},
- \macro{ENOTDIR} e \macro{EROFS}.}
+ errore, nel qual caso \var{errno} assumerà i valori \const{EACCESS},
+ \const{EEXIST}, \const{ENAMETOOLONG}, \const{ENOENT}, \const{ENOSPC},
+ \const{ENOTDIR} e \const{EROFS}.}
\end{functions}
\noindent come per \func{mknod} il file \param{pathname} non deve esistere
(neanche come link simbolico); al solito i permessi specificati da
allocata, per una dimensione massima di \var{size}.
\bodydesc{La funzione restituisce il puntatore \var{buffer} se riesce,
- \macro{NULL} se fallisce, in quest'ultimo caso la variabile
+ \val{NULL} se fallisce, in quest'ultimo caso la variabile
\var{errno} è impostata con i seguenti codici di errore:
\begin{errlist}
- \item[\macro{EINVAL}] L'argomento \var{size} è zero e \var{buffer} non
+ \item[\errcode{EINVAL}] L'argomento \var{size} è zero e \var{buffer} non
è nullo.
- \item[\macro{ERANGE}] L'argomento \var{size} è più piccolo della
+ \item[\errcode{ERANGE}] L'argomento \var{size} è più piccolo della
lunghezza del pathname.
- \item[\macro{EACCESS}] Manca il permesso di lettura o di ricerca su uno dei
+ \item[\errcode{EACCESS}] Manca il permesso di lettura o di ricerca su uno dei
componenti del pathname (cioè su una delle directory superiori alla
corrente).
\end{errlist}}
Di questa funzione esiste una versione \code{char *getwd(char *buffer)}
fatta per compatibilità all'indietro con BSD, che non consente di specificare
la dimensione del buffer; esso deve essere allocato in precedenza ed avere una
-dimensione superiore a \macro{PATH\_MAX} (di solito 256 byte, vedi
+dimensione superiore a \const{PATH\_MAX} (di solito 256 byte, vedi
\secref{sec:sys_limits}); il problema è che in Linux non esiste una dimensione
superiore per un pathname, per cui non è detto che il buffer sia sufficiente a
contenere il nome del file, e questa è la ragione principale per cui questa
Una seconda funzione simile è \code{char *get\_current\_dir\_name(void)} che è
sostanzialmente equivalente ad una \code{getcwd(NULL, 0)}, con la sola
-differenza che essa ritorna il valore della variabile di ambiente \macro{PWD},
+differenza che essa ritorna il valore della variabile di ambiente \val{PWD},
che essendo costruita dalla shell può contenere un pathname comprendente anche
dei link simbolici. Usando \func{getcwd} infatti, essendo il pathname ricavato
risalendo all'indietro l'albero della directory, si perderebbe traccia di ogni
\bodydesc{La funzione restituisce 0 in caso di successo e -1 per un errore,
nel qual caso \var{errno} assumerà i valori:
\begin{errlist}
- \item[\macro{ENOTDIR}] Non si è specificata una directory.
- \item[\macro{EACCESS}] Manca il permesso di ricerca su uno dei componenti di
+ \item[\errcode{ENOTDIR}] Non si è specificata una directory.
+ \item[\errcode{EACCESS}] Manca il permesso di ricerca su uno dei componenti di
\param{path}.
\end{errlist}
- ed inoltre \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
- \macro{ENOMEM}, \macro{ELOOP} e \macro{EIO}.}
+ ed inoltre \const{EFAULT}, \const{ENAMETOOLONG}, \const{ENOENT},
+ \const{ENOMEM}, \const{ELOOP} e \const{EIO}.}
\end{prototype}
\noindent ed ovviamente \param{pathname} deve indicare una directory per la
quale si hanno i permessi di accesso.
pathname.
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
- errore, in caso di errore \var{errno} assumerà i valori \macro{EBADF} o
- \macro{EACCES}.}
+ errore, in caso di errore \var{errno} assumerà i valori \const{EBADF} o
+ \const{EACCES}.}
\end{prototype}
\noindent anche in questo caso \param{fd} deve essere un file descriptor
valido che fa riferimento ad una directory. Inoltre l'unico errore di accesso
non esistente al momento dell'invocazione.
\bodydesc{La funzione ritorna il puntatore alla stringa con il nome o
- \macro{NULL} in caso di fallimento. Non sono definiti errori.}
+ \val{NULL} in caso di fallimento. Non sono definiti errori.}
\end{prototype}
\noindent se si è passato un puntatore \param{string} non nullo questo deve
-essere di dimensione \macro{L\_tmpnam} (costante definita in \file{stdio.h},
-come \macro{P\_tmpdir} e \macro{TMP\_MAX}) ed il nome generato vi verrà
+essere di dimensione \const{L\_tmpnam} (costante definita in \file{stdio.h},
+come \const{P\_tmpdir} e \const{TMP\_MAX}) ed il nome generato vi verrà
copiato automaticamente; altrimenti il nome sarà generato in un buffer statico
interno che verrà sovrascritto ad una chiamata successiva. Successive
invocazioni della funzione continueranno a restituire nomi unici fino ad un
-massimo di \macro{TMP\_MAX} volte. Al nome viene automaticamente aggiunto come
-prefisso la directory specificata da \macro{P\_tmpdir}.
+massimo di \const{TMP\_MAX} volte. Al nome viene automaticamente aggiunto come
+prefisso la directory specificata da \const{P\_tmpdir}.
Di questa funzione esiste una versione rientrante, \func{tmpnam\_r}, che non
-fa nulla quando si passa \macro{NULL} come parametro. Una funzione simile,
+fa nulla quando si passa \val{NULL} come parametro. Una funzione simile,
\func{tempnam}, permette di specificare un prefisso per il file
esplicitamente, il suo prototipo è:
\begin{prototype}{stdio.h}{char *tempnam(const char *dir, const char *pfx)}
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 impostata a
- \macro{ENOMEM} qualora fallisca l'allocazione della stringa.}
+ \val{NULL} in caso di fallimento, \var{errno} viene impostata a
+ \const{ENOMEM} qualora fallisca l'allocazione della stringa.}
\end{prototype}
La funzione alloca con \code{malloc} la stringa in cui restituisce il nome,
directory per il file temporaneo (verificando che esista e sia accessibili),
la prima valida delle seguenti:
\begin{itemize*}
-\item La variabile di ambiente \macro{TMPNAME} (non ha effetto se non è
+\item La variabile di ambiente \const{TMPNAME} (non ha effetto se non è
definita o se il programma chiamante è \acr{suid} o \acr{sgid}, vedi
\secref{sec:file_suid_sgid}).
-\item il valore dell'argomento \param{dir} (se diverso da \macro{NULL}).
-\item Il valore della costante \macro{P\_tmpdir}.
+\item il valore dell'argomento \param{dir} (se diverso da \val{NULL}).
+\item Il valore della costante \const{P\_tmpdir}.
\item la directory \file{/tmp}.
\end{itemize*}
avere creato, fra l'ottenimento del nome e l'apertura del file, un altro file
con lo stesso nome; per questo motivo quando si usa il nome ottenuto da una di
queste funzioni occorre sempre aprire il nuovo file in modalità di esclusione
-(cioè con l'opzione \macro{O\_EXCL} per i file descriptor o con il flag
+(cioè con l'opzione \const{O\_EXCL} per i file descriptor o con il flag
\code{x} per gli stream) che fa fallire l'apertura in caso il file sia già
esistente.
Restituisce un file temporaneo aperto in lettura/scrittura.
\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
+ temporaneo in caso di successo e \val{NULL} in caso di errore, nel qual
caso \var{errno} assumerà i valori:
\begin{errlist}
- \item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
- \item[\macro{EEXIST}] Non è stato possibile generare un nome univoco.
+ \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale.
+ \item[\errcode{EEXIST}] Non è stato possibile generare un nome univoco.
\end{errlist}
- ed inoltre \macro{EFAULT}, \macro{EMFILE}, \macro{ENFILE}, \macro{ENOSPC},
- \macro{EROFS} e \macro{EACCESS}.}
+ ed inoltre \const{EFAULT}, \const{EMFILE}, \const{ENFILE}, \const{ENOSPC},
+ \const{EROFS} e \const{EACCESS}.}
\end{prototype}
\noindent essa restituisce direttamente uno stream già aperto (in modalità
\code{r+b}, si veda \secref{sec:file_fopen}) e pronto per l'uso, che viene
automaticamente cancellato alla sua chiusura o all'uscita dal programma. Lo
standard non specifica in quale directory verrà aperto il file, ma le
-\acr{glibc} prima tentano con \macro{P\_tmpdir} e poi con \file{/tmp}. Questa
+\acr{glibc} prima tentano con \const{P\_tmpdir} e poi con \file{/tmp}. Questa
funzione è rientrante e non soffre di problemi di \textit{race
condition}\index{race condition}.
\param{template}.
\bodydesc{La funzione ritorna il puntatore \param{template} in caso di
- successo e \macro{NULL} in caso di errore, nel qual caso \var{errno}
+ successo e \val{NULL} in caso di errore, nel qual caso \var{errno}
assumerà i valori:
\begin{errlist}
- \item[\macro{EINVAL}] \param{template} non termina con \code{XXXXXX}.
+ \item[\errcode{EINVAL}] \param{template} non termina con \code{XXXXXX}.
\end{errlist}}
\end{prototype}
\noindent dato che \param{template} deve poter essere modificata dalla
\bodydesc{La funzione ritorna il file descriptor in caso successo e
-1 in caso di errore, nel qual caso \var{errno} assumerà i valori:
\begin{errlist}
- \item[\macro{EINVAL}] \param{template} non termina con \code{XXXXXX}.
- \item[\macro{EEXIST}] non è riuscita a creare un file temporano, il
+ \item[\errcode{EINVAL}] \param{template} non termina con \code{XXXXXX}.
+ \item[\errcode{EEXIST}] non è riuscita a creare un file temporano, il
contenuto di \param{template} è indefinito.
\end{errlist}}
\end{prototype}
\noindent come per \func{mktemp} anche in questo caso \param{template} non può
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
+la funzione \func{open}, usando l'opzione \const{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 impostati al valore
\code{0600}\footnote{questo è vero a partire dalle \acr{glibc} 2.0.7, le
\code{XXXXXX} finali di \param{template}.
\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}
+ successo e \val{NULL} in caso di errore, nel qual caso \var{errno}
assumerà i valori:
\begin{errlist}
- \item[\macro{EINVAL}] \param{template} non termina con \code{XXXXXX}.
+ \item[\errcode{EINVAL}] \param{template} non termina con \code{XXXXXX}.
\end{errlist}
più gli altri eventuali codici di errore di \func{mkdir}.}
\end{prototype}
descriptor \var{filedes}.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 per un
- errore, nel qual caso \var{errno} assumerà uno dei valori: \macro{EBADF},
- \macro{ENOENT}, \macro{ENOTDIR}, \macro{ELOOP}, \macro{EFAULT},
- \macro{EACCESS}, \macro{ENOMEM}, \macro{ENAMETOOLONG}.}
+ errore, nel qual caso \var{errno} assumerà uno dei valori: \const{EBADF},
+ \const{ENOENT}, \const{ENOTDIR}, \const{ELOOP}, \const{EFAULT},
+ \const{EACCESS}, \const{ENOMEM}, \const{ENAMETOOLONG}.}
\end{functions}
\noindent il loro comportamento è identico, solo che operano rispettivamente
su un file, su un link simbolico e su un file descriptor.
\textbf{Flag} & \textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{S\_IFMT} & 0170000 & bitmask per i bit del tipo di file \\
- \macro{S\_IFSOCK} & 0140000 & socket \\
- \macro{S\_IFLNK} & 0120000 & link simbolico \\
- \macro{S\_IFREG} & 0100000 & file regolare \\
- \macro{S\_IFBLK} & 0060000 & device a blocchi \\
- \macro{S\_IFDIR} & 0040000 & directory \\
- \macro{S\_IFCHR} & 0020000 & device a caratteri \\
- \macro{S\_IFIFO} & 0010000 & fifo \\
+ \const{S\_IFMT} & 0170000 & bitmask per i bit del tipo di file \\
+ \const{S\_IFSOCK} & 0140000 & socket \\
+ \const{S\_IFLNK} & 0120000 & link simbolico \\
+ \const{S\_IFREG} & 0100000 & file regolare \\
+ \const{S\_IFBLK} & 0060000 & device a blocchi \\
+ \const{S\_IFDIR} & 0040000 & directory \\
+ \const{S\_IFCHR} & 0020000 & device a caratteri \\
+ \const{S\_IFIFO} & 0010000 & fifo \\
\hline
- \macro{S\_ISUID} & 0004000 & set UID bit \\
- \macro{S\_ISGID} & 0002000 & set GID bit \\
- \macro{S\_ISVTX} & 0001000 & sticky bit \\
+ \const{S\_ISUID} & 0004000 & set UID bit \\
+ \const{S\_ISGID} & 0002000 & set GID bit \\
+ \const{S\_ISVTX} & 0001000 & sticky bit \\
\hline
-% \macro{S\_IRWXU} & 00700 & bitmask per i permessi del proprietario \\
- \macro{S\_IRUSR} & 00400 & il proprietario ha permesso di lettura \\
- \macro{S\_IWUSR} & 00200 & il proprietario ha permesso di scrittura \\
- \macro{S\_IXUSR} & 00100 & il proprietario ha permesso di esecuzione\\
+% \const{S\_IRWXU} & 00700 & bitmask per i permessi del proprietario \\
+ \const{S\_IRUSR} & 00400 & il proprietario ha permesso di lettura \\
+ \const{S\_IWUSR} & 00200 & il proprietario ha permesso di scrittura \\
+ \const{S\_IXUSR} & 00100 & il proprietario ha permesso di esecuzione\\
\hline
-% \macro{S\_IRWXG} & 00070 & bitmask per i permessi del gruppo \\
- \macro{S\_IRGRP} & 00040 & il gruppo ha permesso di lettura \\
- \macro{S\_IWGRP} & 00020 & il gruppo ha permesso di scrittura \\
- \macro{S\_IXGRP} & 00010 & il gruppo ha permesso di esecuzione \\
+% \const{S\_IRWXG} & 00070 & bitmask per i permessi del gruppo \\
+ \const{S\_IRGRP} & 00040 & il gruppo ha permesso di lettura \\
+ \const{S\_IWGRP} & 00020 & il gruppo ha permesso di scrittura \\
+ \const{S\_IXGRP} & 00010 & il gruppo ha permesso di esecuzione \\
\hline
-% \macro{S\_IRWXO} & 00007 & bitmask per i permessi di tutti gli altri\\
- \macro{S\_IROTH} & 00004 & gli altri hanno permesso di lettura \\
- \macro{S\_IWOTH} & 00002 & gli altri hanno permesso di esecuzione \\
- \macro{S\_IXOTH} & 00001 & gli altri hanno permesso di esecuzione \\
+% \const{S\_IRWXO} & 00007 & bitmask per i permessi di tutti gli altri\\
+ \const{S\_IROTH} & 00004 & gli altri hanno permesso di lettura \\
+ \const{S\_IWOTH} & 00002 & gli altri hanno permesso di esecuzione \\
+ \const{S\_IXOTH} & 00001 & gli altri hanno permesso di esecuzione \\
\hline
\end{tabular}
\caption{Costanti per l'identificazione dei vari bit che compongono il campo
presenti al di là della dimensione scelta come nuova fine del file.
Un file può sempre essere troncato a zero aprendolo con il flag
-\macro{O\_TRUNC}, ma questo è un caso particolare; per qualunque altra
+\const{O\_TRUNC}, ma questo è un caso particolare; per qualunque altra
dimensione si possono usare le due funzioni \func{truncate} e
\func{ftruncate}, i cui prototipi sono:
\begin{functions}
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
+ \item[\errcode{EBADF}] \var{fd} non è un file descriptor.
+ \item[\errcode{EINVAL}] \var{fd} è un riferimento ad un socket, non a un file
o non è aperto in scrittura.
\end{errlist}
per \func{truncate} si hanno:
\begin{errlist}
- \item[\macro{EACCES}] il file non ha permesso di scrittura o non si ha il
+ \item[\errcode{EACCES}] il file non ha permesso di scrittura o non si ha il
permesso di esecuzione una delle directory del pathname.
- \item[\macro{ETXTBSY}] Il file è un programma in esecuzione.
+ \item[\errcode{ETXTBSY}] Il file è un programma in esecuzione.
\end{errlist}
- ed anche \macro{ENOTDIR}, \macro{ENAMETOOLONG}, \macro{ENOENT},
- \macro{EROFS}, \macro{EIO}, \macro{EFAULT}, \macro{ELOOP}.}
+ ed anche \const{ENOTDIR}, \const{ENAMETOOLONG}, \const{ENOENT},
+ \const{EROFS}, \const{EIO}, \const{EFAULT}, \const{ELOOP}.}
\end{functions}
Se il file è più lungo della lunghezza specificata i dati in eccesso saranno
& & &$\bullet$& & & & \\
\func{creat}
&$\bullet$&$\bullet$&$\bullet$& &$\bullet$&$\bullet$& con
- \macro{O\_CREATE} \\ \func{creat}
+ \const{O\_CREATE} \\ \func{creat}
& &$\bullet$&$\bullet$& &$\bullet$&$\bullet$&
- con \macro{O\_TRUNC} \\ \func{exec}
+ con \const{O\_TRUNC} \\ \func{exec}
&$\bullet$& & & & & & \\
\func{lchown}
& & &$\bullet$& & & & \\
&$\bullet$&$\bullet$&$\bullet$& &$\bullet$&$\bullet$& \\
\func{open}
&$\bullet$&$\bullet$&$\bullet$& &$\bullet$&$\bullet$& con
- \macro{O\_CREATE} \\ \func{open}
+ \const{O\_CREATE} \\ \func{open}
& &$\bullet$&$\bullet$& & & & con
- \macro{O\_TRUNC} \\ \func{pipe}
+ \const{O\_TRUNC} \\ \func{pipe}
&$\bullet$&$\bullet$&$\bullet$& & & & \\
\func{read}
&$\bullet$& & & & & & \\
Cambia i tempi di ultimo accesso e modifica dell'inode specificato da
\param{filename} secondo i campi \var{actime} e \var{modtime} di
-\param{times}. Se questa è \macro{NULL} allora viene usato il tempo corrente.
+\param{times}. Se questa è \val{NULL} allora viene usato il tempo corrente.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EACCESS}] non si ha il permesso di scrittura sul file.
- \item[\macro{ENOENT}] \param{filename} non esiste.
+ \item[\errcode{EACCESS}] non si ha il permesso di scrittura sul file.
+ \item[\errcode{ENOENT}] \param{filename} non esiste.
\end{errlist}}
\end{prototype}
\end{figure}
L'effetto della funzione e i privilegi necessari per eseguirla dipendono da
-cosa è l'argomento \param{times}; se è \macro{NULL} la funzione imposta il
+cosa è l'argomento \param{times}; se è \val{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).
\textbf{\var{st\_mode}} bit & \textbf{Significato} \\
\hline
\hline
- \macro{S\_IRUSR} & \textit{user-read}, l'utente può leggere \\
- \macro{S\_IWUSR} & \textit{user-write}, l'utente può scrivere \\
- \macro{S\_IXUSR} & \textit{user-execute}, l'utente può eseguire \\
+ \const{S\_IRUSR} & \textit{user-read}, l'utente può leggere \\
+ \const{S\_IWUSR} & \textit{user-write}, l'utente può scrivere \\
+ \const{S\_IXUSR} & \textit{user-execute}, l'utente può eseguire \\
\hline
- \macro{S\_IRGRP} & \textit{group-read}, il gruppo può leggere \\
- \macro{S\_IWGRP} & \textit{group-write}, il gruppo può scrivere \\
- \macro{S\_IXGRP} & \textit{group-execute}, il gruppo può eseguire\\
+ \const{S\_IRGRP} & \textit{group-read}, il gruppo può leggere \\
+ \const{S\_IWGRP} & \textit{group-write}, il gruppo può scrivere \\
+ \const{S\_IXGRP} & \textit{group-execute}, il gruppo può eseguire\\
\hline
- \macro{S\_IROTH} & \textit{other-read}, tutti possono leggere \\
- \macro{S\_IWOTH} & \textit{other-write}, tutti possono scrivere \\
- \macro{S\_IXOTH} & \textit{other-execute}, tutti possono eseguire\\
+ \const{S\_IROTH} & \textit{other-read}, tutti possono leggere \\
+ \const{S\_IWOTH} & \textit{other-write}, tutti possono scrivere \\
+ \const{S\_IXOTH} & \textit{other-execute}, tutti possono eseguire\\
\hline
\end{tabular}
\caption{I bit dei permessi di accesso ai file, come definiti in
vengono usati per indicare alcune proprietà speciali dei file. Due di questi
sono i bit detti \acr{suid} (da \textit{set-user-ID bit}) e \acr{sgid} (da
\textit{set-group-ID bit}) che sono identificati dalle costanti
-\macro{S\_ISUID} e \macro{S\_ISGID}.
+\const{S\_ISUID} e \const{S\_ISGID}.
Come spiegato in dettaglio in \secref{sec:proc_exec}, quando si lancia un
programma il comportamento normale del kernel è quello di impostare gli
\cmd{x} in corrispondenza dei permessi di utente o gruppo. La stessa lettera
\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
+l'uso delle due costanti \const{S\_ISUID} e \const{S\_IGID}, i cui valori sono
riportati in \tabref{tab:file_mode_flags}.
Gli stessi bit vengono ad assumere in significato completamente diverso per le
\subsection{Il bit \textsl{sticky}}
\label{sec:file_sticky}
-L'ultimo dei bit rimanenti, identificato dalla costante \macro{S\_ISVTX}, è in
+L'ultimo dei bit rimanenti, identificato dalla costante \const{S\_ISVTX}, è in
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
è consentito ed in caso di errore; nel qual caso la variabile \var{errno}
assumerà i valori:
\begin{errlist}
- \item[\macro{EINVAL}] il valore di \param{mode} non è valido.
- \item[\macro{EACCES}] l'accesso al file non è consentito, o non si ha il
+ \item[\errcode{EINVAL}] il valore di \param{mode} non è valido.
+ \item[\errcode{EACCES}] l'accesso al file non è consentito, o non si ha il
permesso di attraversare una delle directory di \param{pathname}.
- \item[\macro{EROFS}] si è richiesto l'accesso in scrittura per un file su un
- filesystem montato in sola lettura.
+ \item[\errcode{EROFS}] si è richiesto l'accesso in scrittura per un file su
+ un filesystem montato in sola lettura.
\end{errlist}
- ed inoltre \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
- \macro{ENOTDIR}, \macro{ELOOP}, \macro{EIO}.}
+ ed inoltre \const{EFAULT}, \const{ENAMETOOLONG}, \const{ENOENT},
+ \const{ENOTDIR}, \const{ELOOP}, \const{EIO}.}
\end{prototype}
I valori possibili per l'argomento \param{mode} sono esprimibili come
combinazione delle costanti numeriche riportate in
\tabref{tab:file_access_mode_val} (attraverso un OR binario delle stesse). I
primi tre valori implicano anche la verifica dell'esistenza del file, se si
-vuole verificare solo quest'ultima si può usare \macro{F\_OK}, o anche
+vuole verificare solo quest'ultima si può usare \const{F\_OK}, o anche
direttamente \func{stat}. Nel caso in cui \var{pathname} si riferisca ad un
link simbolico, questo viene seguito ed il controllo è fatto sul file a cui
esso fa riferimento.
\textbf{\var{mode}} & \textbf{Significato} \\
\hline
\hline
- \macro{R\_OK} & verifica il permesso di lettura \\
- \macro{W\_OK} & verifica il permesso di scritture \\
- \macro{X\_OK} & verifica il permesso di esecuzione \\
- \macro{F\_OK} & verifica l'esistenza del file \\
+ \const{R\_OK} & verifica il permesso di lettura \\
+ \const{W\_OK} & verifica il permesso di scritture \\
+ \const{X\_OK} & verifica il permesso di esecuzione \\
+ \const{F\_OK} & verifica l'esistenza del file \\
\hline
\end{tabular}
\caption{Valori possibile per il parametro \var{mode} della funzione
\bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per
un errore, in caso di errore \var{errno} può assumere i valori:
\begin{errlist}
- \item[\macro{EPERM}] L'userid effettivo non corrisponde a quello del
+ \item[\errcode{EPERM}] L'userid effettivo non corrisponde a quello del
proprietario del file o non è zero.
- \item[\macro{EROFS}] Il file è su un filesystem in sola lettura.
+ \item[\errcode{EROFS}] Il file è su un filesystem in sola lettura.
\end{errlist}
- ed inoltre \macro{EIO}; \func{chmod} restituisce anche \macro{EFAULT},
- \macro{ENAMETOOLONG}, \macro{ENOENT}, \macro{ENOMEM}, \macro{ENOTDIR},
- \macro{EACCES}, \macro{ELOOP}; \func{fchmod} anche \macro{EBADF}.}
+ ed inoltre \const{EIO}; \func{chmod} restituisce anche \const{EFAULT},
+ \const{ENAMETOOLONG}, \const{ENOENT}, \const{ENOMEM}, \const{ENOTDIR},
+ \const{EACCES}, \const{ELOOP}; \func{fchmod} anche \const{EBADF}.}
\end{functions}
Entrambe le funzioni utilizzano come secondo argomento \param{mode}, una
\textbf{\var{mode}} & \textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{S\_ISUID} & 04000 & set user ID \\
- \macro{S\_ISGID} & 02000 & set group ID \\
- \macro{S\_ISVTX} & 01000 & sticky bit \\
+ \const{S\_ISUID} & 04000 & set user ID \\
+ \const{S\_ISGID} & 02000 & set group ID \\
+ \const{S\_ISVTX} & 01000 & sticky bit \\
\hline
- \macro{S\_IRWXU} & 00700 & l'utente ha tutti i permessi \\
- \macro{S\_IRUSR} & 00400 & l'utente ha il permesso di lettura \\
- \macro{S\_IWUSR} & 00200 & l'utente ha il permesso di scrittura \\
- \macro{S\_IXUSR} & 00100 & l'utente ha il permesso di esecuzione \\
+ \const{S\_IRWXU} & 00700 & l'utente ha tutti i permessi \\
+ \const{S\_IRUSR} & 00400 & l'utente ha il permesso di lettura \\
+ \const{S\_IWUSR} & 00200 & l'utente ha il permesso di scrittura \\
+ \const{S\_IXUSR} & 00100 & l'utente ha il permesso di esecuzione \\
\hline
- \macro{S\_IRWXG} & 00070 & il gruppo ha tutti i permessi \\
- \macro{S\_IRGRP} & 00040 & il gruppo ha il permesso di lettura \\
- \macro{S\_IWGRP} & 00020 & il gruppo ha il permesso di scrittura \\
- \macro{S\_IXGRP} & 00010 & il gruppo ha il permesso di esecuzione \\
+ \const{S\_IRWXG} & 00070 & il gruppo ha tutti i permessi \\
+ \const{S\_IRGRP} & 00040 & il gruppo ha il permesso di lettura \\
+ \const{S\_IWGRP} & 00020 & il gruppo ha il permesso di scrittura \\
+ \const{S\_IXGRP} & 00010 & il gruppo ha il permesso di esecuzione \\
\hline
- \macro{S\_IRWXO} & 00007 & gli altri hanno tutti i permessi \\
- \macro{S\_IROTH} & 00004 & gli altri hanno il permesso di lettura \\
- \macro{S\_IWOTH} & 00002 & gli altri hanno il permesso di scrittura \\
- \macro{S\_IXOTH} & 00001 & gli altri hanno il permesso di esecuzione \\
+ \const{S\_IRWXO} & 00007 & gli altri hanno tutti i permessi \\
+ \const{S\_IROTH} & 00004 & gli altri hanno il permesso di lettura \\
+ \const{S\_IWOTH} & 00002 & gli altri hanno il permesso di scrittura \\
+ \const{S\_IXOTH} & 00001 & gli altri hanno il permesso di esecuzione \\
\hline
\end{tabular}
\caption{Valori delle costanti usate per indicare i vari bit di
comunque alcune limitazioni, previste per motivi di sicurezza. L'uso delle
funzioni infatti è possibile solo se l'userid effettivo del processo
corrisponde a quello del proprietario del file o dell'amministratore,
-altrimenti esse falliranno con un errore di \macro{EPERM}.
+altrimenti esse falliranno con un errore di \errcode{EPERM}.
Ma oltre a questa regola generale, di immediata comprensione, esistono delle
limitazioni ulteriori. Per questo motivo, anche se si è proprietari del file,
\bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per
un errore, in caso di errore \var{errno} può assumere i valori:
\begin{errlist}
- \item[\macro{EPERM}] L'userid effettivo non corrisponde a quello del
+ \item[\errcode{EPERM}] L'userid effettivo non corrisponde a quello del
proprietario del file o non è zero, o utente e gruppo non sono validi
\end{errlist}
- Oltre a questi entrambe restituiscono gli errori \macro{EROFS} e
- \macro{EIO}; \func{chown} restituisce anche \macro{EFAULT},
- \macro{ENAMETOOLONG}, \macro{ENOENT}, \macro{ENOMEM}, \macro{ENOTDIR},
- \macro{EACCES}, \macro{ELOOP}; \func{fchown} anche \macro{EBADF}.}
+ Oltre a questi entrambe restituiscono gli errori \const{EROFS} e
+ \const{EIO}; \func{chown} restituisce anche \const{EFAULT},
+ \const{ENAMETOOLONG}, \const{ENOENT}, \const{ENOMEM}, \const{ENOTDIR},
+ \const{EACCES}, \const{ELOOP}; \func{fchown} anche \const{EBADF}.}
\end{functions}
In Linux soltanto l'amministratore può cambiare il proprietario di un file,
\bodydesc{La funzione restituisce zero in caso di successo e -1 per
un errore, in caso di errore \var{errno} può assumere i valori:
\begin{errlist}
- \item[\macro{EPERM}] L'userid effettivo del processo non è zero.
+ \item[\errcode{EPERM}] L'userid effettivo del processo non è zero.
\end{errlist}
- ed inoltre \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
- \macro{ENOMEM}, \macro{ENOTDIR}, \macro{EACCES}, \macro{ELOOP};
- \macro{EROFS} e \macro{EIO}.}
+ ed inoltre \const{EFAULT}, \const{ENAMETOOLONG}, \const{ENOENT},
+ \const{ENOMEM}, \const{ENOTDIR}, \const{EACCES}, \const{ELOOP};
+ \const{EROFS} e \const{EIO}.}
\end{prototype}
\noindent in questo modo la directory radice del processo diventerà
\param{path} (che ovviamente deve esistere) ed ogni pathname assoluto sarà
specificato da \param{stream}, se questo è già aperto prima lo chiude.
\bodydesc{Le funzioni ritornano un puntatore valido in caso di successo e
- \macro{NULL} in caso di errore, in tal caso \var{errno} assumerà il valore
+ \val{NULL} in caso di errore, in tal caso \var{errno} assumerà il valore
ricevuto dalla funzione sottostante di cui è fallita l'esecuzione.
Gli errori pertanto possono essere quelli di \code{malloc} per tutte
indicate dopo aver specificato il \param{mode} con uno dei valori di
\tabref{tab:file_fopen_mode}. L'uso del carattere \texttt{x} serve per
evitare di sovrascrivere un file già esistente (è analoga all'uso
-dell'opzione \macro{O\_EXCL} in \func{open}), se il file specificato già
+dell'opzione \const{O\_EXCL} in \func{open}), se il file specificato già
esiste e si aggiunge questo carattere a \param{mode} la \func{fopen}
fallisce.
I nuovi file saranno creati secondo quanto visto in
\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
+valore \code{S\_IRUSR|S\_IWUSR|S\_IRGRP|S\_IWGRP|S\_IROTH|S\_IWOTH} (pari a
\var{0666}) modificato secondo il valore di \acr{umask} per il processo (si
veda \secref{sec:file_umask}).
\begin{prototype}{stdio.h}{int fclose(FILE *stream)}
Chiude lo stream \param{stream}.
- \bodydesc{Restituisce 0 in caso di successo e \macro{EOF} in caso di errore,
- nel qual caso imposta \var{errno} a \macro{EBADF} se il file descriptor
+ \bodydesc{Restituisce 0 in caso di successo e \val{EOF} in caso di errore,
+ nel qual caso imposta \var{errno} a \const{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}).}
Linux supporta anche una altra funzione, \func{fcloseall}, come estensione GNU
implementata dalle \acr{glibc}, accessibile avendo definito
-\macro{\_GNU\_SOURCE}, il suo prototipo è:
+\const{\_GNU\_SOURCE}, il suo prototipo è:
\begin{prototype}{stdio.h}{int fcloseall(void)}
Chiude tutti gli stream.
- \bodydesc{Restituisce 0 se non ci sono errori ed \macro{EOF} altrimenti.}
+ \bodydesc{Restituisce 0 se non ci sono errori ed \val{EOF} altrimenti.}
\end{prototype}
\noindent la funzione esegue lo scarico dei dati bufferizzati in uscita
e scarta quelli in ingresso, chiudendo tutti i file. Questa funzione è
raggiungimento della fine del file è considerato un errore, e viene
notificato come tale dai valori di uscita delle varie funzioni. Nella
maggior parte dei casi questo avviene con la restituzione del valore
-intero (di tipo \ctyp{int}) \macro{EOF}\footnote{la costante deve essere
+intero (di tipo \ctyp{int}) \val{EOF}\footnote{la costante deve essere
negativa, le \acr{glibc} usano -1, altre implementazioni possono avere
valori diversi.} definito anch'esso nell'header \file{stdlib.h}.
\bodydesc{Tutte queste funzioni leggono un byte alla volta, che viene
restituito come intero; in caso di errore o fine del file il valore
- di ritorno è \macro{EOF}.}
+ di ritorno è \val{EOF}.}
\end{functions}
A parte \func{getchar}, che si usa in genere per leggere un carattere da
\funcdecl{wint\_t getwchar(void)} Equivalente a \code{getwc(stdin)}.
\bodydesc{Tutte queste funzioni leggono un carattere alla volta, in
- caso di errore o fine del file il valore di ritorno è \macro{WEOF}.}
+ caso di errore o fine del file il valore di ritorno è \const{WEOF}.}
\end{functions}
Per scrivere un carattere si possono usare tre funzioni analoghe alle
\bodydesc{Le funzioni scrivono sempre un carattere alla volta, il cui
valore viene restituito in caso di successo; in caso di errore o
- fine del file il valore di ritorno è \macro{EOF}.}
+ fine del file il valore di ritorno è \val{EOF}.}
\end{functions}
Tutte queste funzioni scrivono sempre un byte alla volta, anche se
prendono come parametro un \ctyp{int} (che pertanto deve essere ottenuto
con un cast da un \ctyp{unsigned char}). Anche il valore di ritorno è
sempre un intero; in caso di errore o fine del file il valore di ritorno
-è \macro{EOF}.
+è \val{EOF}.
Come nel caso dell'I/O binario le \acr{glibc} provvedono per ciascuna
delle funzioni precedenti, come estensione GNU, una seconda funzione, il
\funcdecl{int putw(int w, FILE *stream)} Scrive la parola \param{w} su
\param{stream}.
- \bodydesc{Le funzioni restituiscono la parola \param{w}, o \macro{EOF}
+ \bodydesc{Le funzioni restituiscono la parola \param{w}, o \val{EOF}
in caso di errore o di fine del file.}
\end{functions}
\noindent l'uso di queste funzioni è deprecato in favore dell'uso di
\func{fread} e \func{fwrite}, in quanto non è possibile distinguere il
-valore -1 da una condizione di errore che restituisce \macro{EOF}.
+valore -1 da una condizione di errore che restituisce \val{EOF}.
Uno degli usi più frequenti dell'input/output a caratteri è nei programmi di
\textit{parsing} in cui si analizza il testo; in questo contesto diventa utile
char}, sullo stream \param{stream}.
\bodydesc{La funzione ritorna \param{c} in caso di successo e
- \macro{EOF} in caso di errore.}
+ \val{EOF} in caso di errore.}
\end{prototype}
\noindent benché lo standard ANSI C preveda che l'operazione possa
essere ripetuta per un numero arbitrario di caratteri, alle
prima di usare \func{ungetc}, ma di norma la funzione è intesa per
essere usata per rimandare indietro l'ultimo carattere letto.
-Nel caso \param{c} sia un \macro{EOF} la funzione non fa nulla, e
-restituisce sempre \macro{EOF}; così si può usare \func{ungetc} anche
+Nel caso \param{c} sia un \val{EOF} la funzione non fa nulla, e
+restituisce sempre \val{EOF}; così si può usare \func{ungetc} anche
con il risultato di una lettura alla fine del file.
Se si è alla fine del file si può comunque rimandare indietro un
massimo di \param{size} byte.
\bodydesc{Le funzioni restituiscono l'indirizzo \param{string} in caso
- di successo o \macro{NULL} in caso di errore.}
+ di successo o \val{NULL} in caso di errore.}
\end{functions}
Entrambe le funzioni effettuano la lettura (dal file specificato \func{fgets},
capo della tastiera), ma \func{gets} sostituisce \verb|'\n'| con uno zero,
mentre \func{fgets} aggiunge uno zero dopo il \textit{newline}, che resta
dentro la stringa. Se la lettura incontra la fine del file (o c'è un errore)
-viene restituito un \macro{NULL}, ed il buffer \param{buf} non viene toccato.
+viene restituito un \val{NULL}, ed il buffer \param{buf} non viene toccato.
L'uso di \func{gets} è deprecato e deve essere assolutamente evitato; la
funzione infatti non controlla il numero di byte letti, per cui nel caso la
stringa letta superi le dimensioni del buffer, si avrà un \textit{buffer
\param{stream} la linea \param{string}.
\bodydesc{Le funzioni restituiscono un valore non negativo in caso di
- successo o \macro{EOF} in caso di errore.}
+ successo o \val{EOF} in caso di errore.}
\end{functions}
Dato che in questo caso si scrivono i dati in uscita \func{puts} non ha i
linea \param{ws} di caratteri estesi sul file \param{stream}.
\bodydesc{Le funzioni ritornano rispettivamente \param{ws} o un numero
- non negativo in caso di successo e \macro{NULL} o \macro{EOF} in
+ non negativo in caso di successo e \val{NULL} o \val{EOF} in
caso di errore o fine del file.}
\end{functions}
\noindent il cui comportamento è identico a quello di \func{fgets} e
Per questo motivo le \acr{glibc} prevedono, come estensione GNU, due
nuove funzioni per la gestione dell'input/output di linea, il cui uso
permette di risolvere questi problemi. L'uso di queste funzioni deve
-essere attivato definendo la macro \macro{\_GNU\_SOURCE} prima di
+essere attivato definendo la macro \const{\_GNU\_SOURCE} prima di
includere \file{stdio.h}. La prima delle due, \func{getline}, serve per
leggere una linea terminata da un newline esattamente allo stesso modo
di \func{fgets}, il suo prototipo è:
i valori delle variabili, secondo la tecnica spiegata in
\secref{sec:proc_var_passing}).
-Se si passa alla funzione l'indirizzo di un puntatore impostato a \macro{NULL}
+Se si passa alla funzione l'indirizzo di un puntatore impostato a \val{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 linea letta. Un esempio di codice può
\textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \cmd{\#} & Chiede la conversione in forma alternativa. \\
- \cmd{0} & La conversione è riempita con zeri alla sinistra del valore.\\
- \cmd{-} & La conversione viene allineata a sinistra sul bordo del campo.\\
- \cmd{' '}& Mette uno spazio prima di un numero con segno di valore
+ \val{\#} & Chiede la conversione in forma alternativa. \\
+ \val{0} & La conversione è riempita con zeri alla sinistra del valore.\\
+ \val{-} & La conversione viene allineata a sinistra sul bordo del campo.\\
+ \val{' '}& Mette uno spazio prima di un numero con segno di valore
positivo\\
- \cmd{+} & Mette sempre il segno ($+$ o $-$) prima di un numero.\\
+ \val{+} & Mette sempre il segno ($+$ o $-$) prima di un numero.\\
\hline
\end{tabular}
\caption{I valori dei flag per il formato di \func{printf}}
% [n. parametro $] [flag] [[larghezza] [. precisione]] [tipo] conversione
\end{verbatim}
\end{center}
-in cui tutti i valori tranne il \cmd{\%} e lo specificatore di conversione
+in cui tutti i valori tranne il \val{\%} e lo specificatore di conversione
sono opzionali (e per questo sono indicati fra parentesi quadre); si possono
usare più elementi opzionali, nel qual caso devono essere specificati in
questo ordine:
\begin{itemize*}
-\item uno specificatore del parametro da usare (terminato da un \cmd{\$}),
+\item uno specificatore del parametro da usare (terminato da un \val{\$}),
\item uno o più flag (i cui valori possibili sono riassunti in
\tabref{tab:file_format_flag}) che controllano il formato di stampa della
conversione,
parametri dovrà essere opportunamente trattata (l'argomento è esaminato in
\secref{sec:proc_variadic}), e dopo l'esecuzione della funzione l'argomento
\param{ap} non sarà più utilizzabile (in generale dovrebbe essere eseguito un
-\macro{va\_end(ap)} ma in Linux questo non è necessario).
+\code{va\_end(ap)} ma in Linux questo non è necessario).
Come per \func{sprintf} anche per \func{vsprintf} esiste una analoga
\func{vsnprintf} che pone un limite sul numero di caratteri che vengono
Per eliminare alla radice questi problemi, le \acr{glibc} supportano una
specifica estensione GNU che alloca dinamicamente tutto lo spazio necessario;
-l'estensione si attiva al solito definendo \macro{\_GNU\_SOURCE}, le due
+l'estensione si attiva al solito definendo \const{\_GNU\_SOURCE}, le due
funzioni sono:
\begin{functions}
\headdecl{stdio.h}
\bodydesc{Le funzioni ritornano il numero di elementi assegnati. Questi
possono essere in numero inferiore a quelli specificati, ed anche zero.
Quest'ultimo valore significa che non si è trovata corrispondenza. In caso
- di errore o fine del file viene invece restituito \macro{EOF}.}
+ di errore o fine del file viene invece restituito \val{EOF}.}
\end{functions}
\noindent e come per le analoghe funzioni di scrittura esistono le relative
\func{vscanf}, \func{vfscanf} \func{vsscanf} che usano un puntatore ad una
\bodydesc{Restituisce il numero del file descriptor in caso di successo, e
-1 qualora \param{stream} non sia valido, nel qual caso imposta
- \var{errno} a \macro{EBADF}.}
+ \var{errno} a \const{EBADF}.}
\end{prototype}
\noindent ed in questo modo diventa possibile usare direttamente \func{fcntl}.
stream. In genere conviene allocarlo con \func{malloc} e disallocarlo dopo la
chiusura del file; ma fintanto che il file è usato all'interno di una
funzione, può anche essere usata una variabile automatica. In \file{stdio.h} è
-definita la macro \macro{BUFSIZ}, che indica le dimensioni generiche del
+definita la macro \const{BUFSIZ}, che indica le dimensioni generiche del
buffer di uno stream; queste vengono usate dalla funzione \func{setbuf}. Non
è detto però che tale dimensione corrisponda sempre al valore ottimale (che
può variare a seconda del dispositivo).
\textbf{Valore} & \textbf{Modalità} \\
\hline
\hline
- \macro{\_IONBF} & \textit{unbuffered}\\
- \macro{\_IOLBF} & \textit{line buffered}\\
- \macro{\_IOFBF} & \textit{fully buffered}\\
+ \const{\_IONBF} & \textit{unbuffered}\\
+ \const{\_IOLBF} & \textit{line buffered}\\
+ \const{\_IOFBF} & \textit{fully buffered}\\
\hline
\end{tabular}
\caption{Valori del parametro \param{mode} di \func{setvbuf}
\end{table}
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}
+\val{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
opportuni valori elencati in \tabref{tab:file_stream_buf_mode}. Qualora si
\headdecl{stdio.h}
\funcdecl{void setbuf(FILE *stream, char *buf)} Disabilita la
- bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \param{buf}
- come buffer di dimensione \macro{BUFSIZ} in modalità \textit{fully buffered}.
+ bufferizzazione se \param{buf} è \val{NULL}, altrimenti usa \param{buf}
+ come buffer di dimensione \const{BUFSIZ} in modalità \textit{fully buffered}.
\funcdecl{void setbuffer(FILE *stream, char *buf, size\_t size)} Disabilita
- la bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \param{buf}
+ la bufferizzazione se \param{buf} è \val{NULL}, altrimenti usa \param{buf}
come buffer di dimensione \param{size} in modalità \textit{fully buffered}.
\funcdecl{void setlinebuf(FILE *stream)} Pone lo stream in modalità
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, impostando \var{errno} a \macro{EBADF} se \param{stream} non è
+ \bodydesc{Restituisce zero in caso di successo, ed \val{EOF} in caso di
+ errore, impostando \var{errno} a \const{EBADF} se \param{stream} non è
aperto o non è aperto in scrittura, o ad uno degli errori di
\func{write}.}
\end{prototype}
\noindent anche di questa funzione esiste una analoga
-\func{fflush\_unlocked}\footnote{accessibile definendo \macro{\_BSD\_SOURCE} o
- \macro{\_SVID\_SOURCE} o \macro{\_GNU\_SOURCE}.} che non effettua il blocco
+\func{fflush\_unlocked}\footnote{accessibile definendo \const{\_BSD\_SOURCE} o
+ \const{\_SVID\_SOURCE} o \const{\_GNU\_SOURCE}.} che non effettua il blocco
dello stream.
-Se \param{stream} è \macro{NULL} lo scarico dei dati è forzato per tutti gli
+Se \param{stream} è \val{NULL} lo scarico dei dati è forzato per tutti gli
stream aperti. Esistono però circostanze, ad esempio quando si vuole essere
sicuri che sia stato eseguito tutto l'output su terminale, in cui serve poter
effettuare lo scarico dei dati solo per gli stream in modalità line buffered;
Cancella i buffer di input e di output dello stream \param{stream}.
- \bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di
+ \bodydesc{Restituisce zero in caso di successo, ed \val{EOF} in caso di
errore.}
\end{prototype}
necessita di compiere più di una operazione sullo stream atomicamente, per
questo motivo le librerie provvedono anche delle funzioni che permettono la
gestione esplicita dei blocchi sugli stream; queste funzioni sono disponibili
-definendo \macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono:
+definendo \const{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono:
\begin{functions}
\headdecl{stdio.h}
all'acquisizione implicita del blocco sullo stream.
\bodydesc{Restituisce lo stato di locking interno dello stream con uno dei
- valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.}
+ valori \const{FSETLOCKING\_INTERNAL} o \const{FSETLOCKING\_BYCALLER}.}
\end{prototype}
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
+\item[\const{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco
implicito predefinito.
-\item[\macro{FSETLOCKING\_BYCALLER}] Al ritorno della funzione sarà l'utente a
+\item[\const{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à
+\item[\const{FSETLOCKING\_QUERY}] Restituisce lo stato corrente della modalità
di blocco dello stream.
\end{basedescript}
la 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 impostata in precedenza
-(questa è una potenziale sorgente di \textit{race condition}\index{race
- condition}, vedi \secref{sec:file_atomic}).
+(questa è una potenziale sorgente di \textit{race condition}
+\index{race condition}, vedi \secref{sec:file_atomic}).
Non tutti i file supportano la capacità di eseguire una \func{lseek}, in
questo caso la funzione ritorna l'errore \macro{EPIPE}. Questo, oltre che per
Le macro disponibili per i vari standard sono le seguenti:
\begin{basedescript}{\desclabelwidth{3cm}\desclabelstyle{\nextlinelabel}}
-\item[\macro{\_POSIX\_SOURCE}] definendo questa macro si rendono disponibili
+\item[\const{\_POSIX\_SOURCE}] definendo questa macro si rendono disponibili
tutte le funzionalità dello standard POSIX.1 (la versione IEEE Standard
1003.1) insieme a tutte le funzionalità dello standard ISO C. Se viene anche
- definita con un intero positivo la macro \macro{\_POSIX\_C\_SOURCE} lo stato
+ definita con un intero positivo la macro \const{\_POSIX\_C\_SOURCE} lo stato
di questa non viene preso in considerazione.
-\item[\macro{\_POSIX\_C\_SOURCE}] definendo questa macro ad un valore intero
+\item[\const{\_POSIX\_C\_SOURCE}] definendo questa macro ad un valore intero
positivo si controlla quale livello delle funzionalità specificate da POSIX
viene messa a disposizione; più alto è il valore maggiori sono le
funzionalità. Se è uguale a '1' vengono attivate le funzionalità specificate
Standard 1003.1b-1993). Un valore maggiore o uguale a `199506L' attiva le
funzionalità POSIX.1 specificate nell'edizione del 1996 (ISO/IEC 9945-1:
1996). Valori superiori abiliteranno ulteriori estensioni.
-\item[\macro{\_BSD\_SOURCE}] definendo questa macro si attivano le
+\item[\const{\_BSD\_SOURCE}] definendo questa macro si attivano le
funzionalità derivate da BSD4.3, insieme a quelle previste dagli standard
ISO C, POSIX.1 e POSIX.2. Alcune delle funzionalità previste da BSD sono
però in conflitto con le corrispondenti definite nello standard POSIX.1, in
questo caso occorre pertanto anche usare l'opzione \cmd{-lbsd-compat} con il
compilatore per indicargli di utilizzare le versioni nella libreria di
compatibilità prima di quelle normali.
-\item[\macro{\_SVID\_SOURCE}] definendo questa macro si attivano le
+\item[\const{\_SVID\_SOURCE}] definendo questa macro si attivano le
funzionalità derivate da SVID. Esse comprendono anche quelle definite negli
standard ISO C, POSIX.1, POSIX.2, and X/Open.
-\item[\macro{\_XOPEN\_SOURCE}] definendo questa macro si attivano le
+\item[\const{\_XOPEN\_SOURCE}] definendo questa macro si attivano le
funzionalità descritte nella \textit{X/Open Portability Guide}. Anche queste
sono un soprainsieme di quelle definite in POSIX.1 e POSIX.2 ed in effetti
- sia \macro{\_POSIX\_SOURCE} che \macro{\_POSIX\_C\_SOURCE} vengono
+ sia \const{\_POSIX\_SOURCE} che \const{\_POSIX\_C\_SOURCE} vengono
automaticamente definite. Sono incluse anche ulteriori funzionalità
disponibili in BSD e SVID. Se il valore della macro è posto a 500 questo
include anche le nuove definizioni introdotte con la \textit{Single UNIX
Specification, version 2}, cioè Unix98.
-\item[\macro{\_XOPEN\_SOURCE\_EXTENDED}] definendo questa macro si attivano le
+\item[\const{\_XOPEN\_SOURCE\_EXTENDED}] definendo questa macro si attivano le
ulteriori funzionalità necessarie ad essere conformi al rilascio del marchio
\textit{X/Open Unix}.
-\item[\macro{\_ISOC99\_SOURCE}] definendo questa macro si attivano le
+\item[\const{\_ISOC99\_SOURCE}] definendo questa macro si attivano le
funzionalità previste per la revisione delle librerie standard del C
denominato ISO C99. Dato che lo standard non è ancora adottato in maniera
ampia queste non sono abilitate automaticamente, ma le \acr{glibc} hanno già
un'implementazione completa che può essere attivata definendo questa macro.
-\item[\macro{\_LARGEFILE\_SOURCE}] definendo questa macro si attivano le
+\item[\const{\_LARGEFILE\_SOURCE}] definendo questa macro si attivano le
funzionalità per il supporto dei file di grandi dimensioni (il \textit{Large
File Support} o LFS) con indici e dimensioni a 64 bit.
-\item[\macro{\_GNU\_SOURCE}] definendo questa macro si attivano tutte le
+\item[\const{\_GNU\_SOURCE}] definendo questa macro si attivano tutte le
funzionalità disponibili: ISO C89, ISO C99, POSIX.1, POSIX.2, BSD, SVID,
X/Open, LFS più le estensioni specifiche GNU. Nel caso in cui BSD e POSIX
confliggano viene data la precedenza a POSIX.
In particolare è da sottolineare che le \acr{glibc} supportano alcune
estensioni specifiche GNU, che non sono comprese in nessuno degli
standard citati. Per poterle utilizzare esse devono essere attivate
-esplicitamente definendo la macro \macro{\_GNU\_SOURCE} prima di
+esplicitamente definendo la macro \const{\_GNU\_SOURCE} prima di
includere i vari header file.
\newcommand{\code}[1]{\texttt{#1}} % for simple code
\newcommand{\func}[1]{%
\index{#1@{{\tt {#1}} (funzione)}}\texttt{#1}%
-} % library function (or system call)
+}
\newcommand{\macro}[1]{%
-\index{#1@{{\tt {#1}} (costante)}}\texttt{#1}
+\index{#1@{{\tt {#1}} (macro)}}\texttt{#1}
} % macro constant
\newcommand{\errcode}[1]{%
\index{#1@{{\tt {#1}} (errore)}}\texttt{#1}%
} % macro constant
\newcommand{\var}[1]{\texttt{#1}} % variable
-\newcommand{\const}[1]{\texttt{#1}} % constant name
+\newcommand{\val}[1]{\texttt{#1}} % value
+\newcommand{\const}[1]{
+\index{#1@{{\tt {#1}} (costante)}}\texttt{#1}
+} % constant name
\newcommand{\file}[1]{\texttt{#1}} % file name
\newcommand{\link}[1]{\texttt{#1}} % html link
\newcommand{\ctyp}[1]{\texttt{#1}} % C standard type
\newcommand{\type}[1]{%
-\index{#1@{\tt {#1}}}\texttt{#1}%
+\index{#1@{{\tt {#1}} (tipo)}}\texttt{#1}%
} % system type
\newcommand{\param}[1]{\texttt{#1}} % function parameter
\newcommand{\acr}[1]{\textsl{#1}} % acrostic (for pid, suid, etc.)
\end{lstlisting}
questo vettore sarà immagazzinato in questo segmento. Anch'esso viene
allocato all'avvio, e tutte le variabili vengono inizializzate a zero (ed i
- puntatori a \macro{NULL}).\footnote{si ricordi che questo vale solo per le
+ puntatori a \val{NULL}).\footnote{si ricordi che questo vale solo per le
variabili che vanno nel segmento dati, e non è affatto vero in generale.}
Storicamente questo segmento viene chiamato BBS (da \textit{block started by
Alloca \var{size} byte nello heap. La memoria viene inizializzata a 0.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
- di successo e \macro{NULL} in caso di fallimento, nel qual caso
+ di successo e \val{NULL} in caso di fallimento, nel qual caso
\var{errno} assumerà il valore \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
+ di successo e \val{NULL} in caso di fallimento, nel qual caso
\var{errno} assumerà il valore \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
+ di successo e \val{NULL} in caso di fallimento, nel qual caso
\var{errno} assumerà il valore \macro{ENOMEM}.
\funcdecl{void free(void *ptr)}
Disalloca lo spazio di memoria puntato da \var{ptr}.
le \acr{glibc} e le \acr{uClib} quando il valore di \param{size} è nullo.
Nel primo caso viene comunque restituito un puntatore valido, anche se non è
chiaro a cosa esso possa fare riferimento, nel secondo caso viene restituito
- \func{NULL}. Il comportamento è analogo con \code{realloc(NULL, 0)}.} e
+ \val{NULL}. Il comportamento è analogo con \code{realloc(NULL, 0)}.} e
siccome i puntatori ritornati sono di tipo generico non è necessario
effettuare un cast per assegnarli a puntatori al tipo di variabile per la
quale si effettua l'allocazione.
La funzione \func{realloc} si usa invece per cambiare (in genere aumentare) la
dimensione di un'area di memoria precedentemente allocata, la funzione vuole
in ingresso il puntatore restituito dalla precedente chiamata ad una
-\func{malloc} (se è passato un valore \macro{NULL} allora la funzione si
+\func{malloc} (se è passato un valore \val{NULL} allora la funzione si
comporta come \func{malloc})\footnote{questo è vero per Linux e
l'implementazione secondo lo standard ANSI C, ma non è vero per alcune
vecchie implementazioni, inoltre alcune versioni delle librerie del C
Un errore abbastanza frequente (specie se si ha a che fare con array di
puntatori) è quello di chiamare \func{free} più di una volta sullo stesso
puntatore; per evitare questo problema una soluzione di ripiego è quella di
-assegnare sempre a \macro{NULL} ogni puntatore liberato con \func{free}, dato
+assegnare sempre a \val{NULL} ogni puntatore liberato con \func{free}, dato
che, quando il parametro è un puntatore nullo, \func{free} non esegue nessuna
operazione.
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
+ di successo e \val{NULL} in caso di fallimento, nel qual caso
\var{errno} assumerà il valore \macro{ENOMEM}.
\end{prototype}
\noindent ma in questo caso non è più necessario liberare la memoria (e quindi
della fine del segmento dati.
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
+ allocata in caso di successo e \val{NULL} in caso di fallimento, nel qual
caso \macro{errno} assumerà il valore \macro{ENOMEM}.
\end{functions}
\noindent in genere si usa \func{sbrk} con un valore zero per ottenere
Come per la lista dei parametri anche questa lista è un array di puntatori a
caratteri, ciascuno dei quali punta ad una stringa, terminata da un
-\macro{NULL}. A differenza di \var{argv[]} in questo caso non si ha una
+\val{NULL}. A differenza di \var{argv[]} in questo caso non si ha una
lunghezza dell'array data da un equivalente di \var{argc}, ma la lista è
terminata da un puntatore nullo.
Esamina l'ambiente del processo cercando una stringa che corrisponda a
quella specificata da \param{name}.
- \bodydesc{La funzione ritorna \macro{NULL} se non trova nulla, o il
+ \bodydesc{La funzione ritorna \val{NULL} se non trova nulla, o il
puntatore alla stringa che corrisponde (di solito nella forma
\cmd{NOME=valore}).}
\end{prototype}
Una modalità diversa, che può essere applicata solo quando il tipo dei
parametri lo rende possibile, è quella che prevede di usare un valore speciale
come ultimo argomento (come fa ad esempio \func{execl} che usa un puntatore
-\macro{NULL} per indicare la fine della lista degli argomenti).
+\val{NULL} per indicare la fine della lista degli argomenti).
\subsection{Potenziali problemi con le variabili automatiche}
interi, che sono in genere fissati dall'architettura hardware (le analoghe
informazioni per i dati in virgola mobile sono definite a parte, ed
accessibili includendo \file{float.h}). Lo standard prevede anche un'altra
-costante, \macro{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
+costante, \const{FOPEN\_MAX}, che può non essere fissa e che pertanto non è
definita in \file{limits.h}; essa deve essere definita in \file{stdio.h} ed
avere un valore minimo di 8.
\textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{MB\_LEN\_MAX}& 16 & massima dimensione di un
+ \const{MB\_LEN\_MAX}& 16 & massima dimensione di un
carattere esteso\\
- \macro{CHAR\_BIT} & 8 & bit di \ctyp{char}\\
- \macro{UCHAR\_MAX}& 255 & massimo di \ctyp{unsigned char}\\
- \macro{SCHAR\_MIN}& -128 & minimo di \ctyp{signed char}\\
- \macro{SCHAR\_MAX}& 127 & massimo di \ctyp{signed char}\\
- \macro{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
- \macro{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
- \macro{SHRT\_MIN} & -32768 & minimo di \ctyp{short}\\
- \macro{SHRT\_MAX} & 32767 & massimo di \ctyp{short}\\
- \macro{USHRT\_MAX}& 65535 & massimo di \ctyp{unsigned short}\\
- \macro{INT\_MAX} & 2147483647 & minimo di \ctyp{int}\\
- \macro{INT\_MIN} &-2147483648 & minimo di \ctyp{int}\\
- \macro{UINT\_MAX} & 4294967295 & massimo di \ctyp{unsigned int}\\
- \macro{LONG\_MAX} & 2147483647 & massimo di \ctyp{long}\\
- \macro{LONG\_MIN} &-2147483648 & minimo di \ctyp{long}\\
- \macro{ULONG\_MAX}& 4294967295 & massimo di \ctyp{unsigned long}\\
+ \const{CHAR\_BIT} & 8 & bit di \ctyp{char}\\
+ \const{UCHAR\_MAX}& 255 & massimo di \ctyp{unsigned char}\\
+ \const{SCHAR\_MIN}& -128 & minimo di \ctyp{signed char}\\
+ \const{SCHAR\_MAX}& 127 & massimo di \ctyp{signed char}\\
+ \const{CHAR\_MIN} &\footnotemark& minimo di \ctyp{char}\\
+ \const{CHAR\_MAX} &\footnotemark& massimo di \ctyp{char}\\
+ \const{SHRT\_MIN} & -32768 & minimo di \ctyp{short}\\
+ \const{SHRT\_MAX} & 32767 & massimo di \ctyp{short}\\
+ \const{USHRT\_MAX}& 65535 & massimo di \ctyp{unsigned short}\\
+ \const{INT\_MAX} & 2147483647 & minimo di \ctyp{int}\\
+ \const{INT\_MIN} &-2147483648 & minimo di \ctyp{int}\\
+ \const{UINT\_MAX} & 4294967295 & massimo di \ctyp{unsigned int}\\
+ \const{LONG\_MAX} & 2147483647 & massimo di \ctyp{long}\\
+ \const{LONG\_MIN} &-2147483648 & minimo di \ctyp{long}\\
+ \const{ULONG\_MAX}& 4294967295 & massimo di \ctyp{unsigned long}\\
\hline
\end{tabular}
\caption{Costanti definite in \file{limits.h} in conformità allo standard
\label{tab:sys_ansic_macro}
\end{table}
-\footnotetext[1]{il valore può essere 0 o \macro{SCHAR\_MIN} a seconda che il
+\footnotetext[1]{il valore può essere 0 o \const{SCHAR\_MIN} a seconda che il
sistema usi caratteri con segno o meno.}
-\footnotetext[2]{il valore può essere \macro{UCHAR\_MAX} o \macro{SCHAR\_MAX}
+\footnotetext[2]{il valore può essere \const{UCHAR\_MAX} o \const{SCHAR\_MAX}
a seconda che il sistema usi caratteri con segno o meno.}
A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
\textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
- \macro{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
- \macro{ULLONG\_MAX}&18446744073709551615&
+ \const{LLONG\_MAX}& 9223372036854775807& massimo di \ctyp{long long}\\
+ \const{LLONG\_MIN}&-9223372036854775808& minimo di \ctyp{long long}\\
+ \const{ULLONG\_MAX}&18446744073709551615&
massimo di \ctyp{unsigned long long}\\
\hline
\end{tabular}
\textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{ARG\_MAX} &131072& dimensione massima degli argomenti
+ \const{ARG\_MAX} &131072& dimensione massima degli argomenti
passati ad una funzione della famiglia
\func{exec}.\\
- \macro{CHILD\_MAX} & 999& numero massimo di processi contemporanei
+ \const{CHILD\_MAX} & 999& numero massimo di processi contemporanei
che un utente può eseguire.\\
- \macro{OPEN\_MAX} & 256& numero massimo di file che un processo
+ \const{OPEN\_MAX} & 256& numero massimo di file che un processo
può mantenere aperti in contemporanea.\\
- \macro{STREAM\_MAX}& 8& massimo numero di stream aperti per
+ \const{STREAM\_MAX}& 8& massimo numero di stream aperti per
processo in contemporanea.\\
- \macro{TZNAME\_MAX}& 6& dimensione massima del nome di una
+ \const{TZNAME\_MAX}& 6& dimensione massima del nome di una
\texttt{timezone} (vedi
\secref{sec:sys_time_base})).\\
- \macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
+ \const{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}.\\
+ \const{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
\hline
\hline
\end{tabular}
lasciate indefinite, ed i loro valori dei limiti devono essere accessibili
solo attraverso \func{sysconf}. In realtà queste vengono sempre definite ad
un valore generico. Si tenga presente poi che alcuni di questi limiti possono
-assumere valori molto elevati (come \macro{CHILD\_MAX}), e non è pertanto il
+assumere valori molto elevati (come \const{CHILD\_MAX}), e non è pertanto il
caso di utilizzarli per allocare staticamente della memoria.
A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
\textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{\_POSIX\_ARG\_MAX} & 4096& dimensione massima degli argomenti
+ \const{\_POSIX\_ARG\_MAX} & 4096& dimensione massima degli argomenti
passati ad una funzione della famiglia
\func{exec}.\\
- \macro{\_POSIX\_CHILD\_MAX} & 6& numero massimo di processi
+ \const{\_POSIX\_CHILD\_MAX} & 6& numero massimo di processi
contemporanei che un utente può
eseguire.\\
- \macro{\_POSIX\_OPEN\_MAX} & 16& numero massimo di file che un processo
+ \const{\_POSIX\_OPEN\_MAX} & 16& numero massimo di file che un processo
può mantenere aperti in
contemporanea.\\
- \macro{\_POSIX\_STREAM\_MAX} & 8& massimo numero di stream aperti per
+ \const{\_POSIX\_STREAM\_MAX} & 8& massimo numero di stream aperti per
processo in contemporanea.\\
- \macro{\_POSIX\_TZNAME\_MAX} & & dimensione massima del nome di una
+ \const{\_POSIX\_TZNAME\_MAX} & & dimensione massima del nome di una
\texttt{timezone} (vedi
\secref{sec:sys_date}). \\
- \macro{\_POSIX\_NGROUPS\_MAX}& 0& numero di gruppi supplementari per
+ \const{\_POSIX\_NGROUPS\_MAX}& 0& numero di gruppi supplementari per
processo (vedi
\secref{sec:proc_access_id}).\\
- \macro{\_POSIX\_SSIZE\_MAX} &32767& valore massimo del tipo
+ \const{\_POSIX\_SSIZE\_MAX} &32767& valore massimo del tipo
\type{ssize\_t}.\\
- \macro{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
- \macro{\_POSIX\_AIO\_MAX} & 1& \\
+ \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
+ \const{\_POSIX\_AIO\_MAX} & 1& \\
\hline
\hline
\end{tabular}
\textbf{Macro}&\textbf{Significato}\\
\hline
\hline
- \macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il
+ \const{\_POSIX\_JOB\_CONTROL}& il sistema supporta il
\textit{job control} (vedi
\secref{sec:sess_job_control}).\\
- \macro{\_POSIX\_SAVED\_IDS} & il sistema supporta gli identificatori del
+ \const{\_POSIX\_SAVED\_IDS} & il sistema supporta gli identificatori del
gruppo \textit{saved} (vedi
\secref{sec:proc_access_id})
per il controllo di accesso dei processi\\
- \macro{\_POSIX\_VERSION} & fornisce la versione dello standard POSIX.1
+ \const{\_POSIX\_VERSION} & fornisce la versione dello standard POSIX.1
supportata nel formato YYYYMML (ad esempio
199009L).\\
\hline
\textbf{Parametro}&\textbf{Macro sostituita} &\textbf{Significato}\\
\hline
\hline
- \texttt{\_SC\_ARG\_MAX} &\macro{ARG\_MAX}&
+ \texttt{\_SC\_ARG\_MAX} &\const{ARG\_MAX}&
La dimensione massima degli argomenti passati ad una funzione
della famiglia \func{exec}.\\
- \texttt{\_SC\_CHILD\_MAX}&\macro{\_CHILD\_MAX}&
+ \texttt{\_SC\_CHILD\_MAX}&\const{\_CHILD\_MAX}&
Il numero massimo di processi contemporanei che un utente può
eseguire.\\
- \texttt{\_SC\_OPEN\_MAX}&\macro{\_OPEN\_MAX}&
+ \texttt{\_SC\_OPEN\_MAX}&\const{\_OPEN\_MAX}&
Il numero massimo di file che un processo può mantenere aperti in
contemporanea.\\
- \texttt{\_SC\_STREAM\_MAX}& \macro{STREAM\_MAX}&
+ \texttt{\_SC\_STREAM\_MAX}& \const{STREAM\_MAX}&
Il massimo numero di stream che un processo può mantenere aperti in
contemporanea. Questo limite previsto anche dallo standard ANSI C, che
specifica la macro {FOPEN\_MAX}.\\
- \texttt{\_SC\_TZNAME\_MAX}&\macro{TZNAME\_MAX}&
+ \texttt{\_SC\_TZNAME\_MAX}&\const{TZNAME\_MAX}&
La dimensione massima di un nome di una \texttt{timezone} (vedi
\secref{sec:sys_date}).\\
- \texttt{\_SC\_NGROUPS\_MAX}&\macro{NGROUP\_MAX}&
+ \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
Massimo numero di gruppi supplementari che può avere un processo (vedi
\secref{sec:proc_access_id}).\\
- \texttt{\_SC\_SSIZE\_MAX}&\macro{SSIZE\_MAX}&
+ \texttt{\_SC\_SSIZE\_MAX}&\const{SSIZE\_MAX}&
valore massimo del tipo di dato \type{ssize\_t}.\\
- \texttt{\_SC\_CLK\_TCK}& \macro{CLK\_TCK} &
+ \texttt{\_SC\_CLK\_TCK}& \const{CLK\_TCK} &
Il numero di \textit{clock tick} al secondo, cioè l'unità di misura del
\textit{process time} (vedi \secref{sec:sys_unix_time}).\\
- \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
+ \texttt{\_SC\_JOB\_CONTROL}&\const{\_POSIX\_JOB\_CONTROL}&
Indica se è supportato il \textit{job control} (vedi
\secref{sec:sess_job_control}) in stile POSIX.\\
- \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
+ \texttt{\_SC\_SAVED\_IDS}&\const{\_POSIX\_SAVED\_IDS}&
Indica se il sistema supporta i \textit{saved id} (vedi
\secref{sec:proc_access_id}).\\
- \texttt{\_SC\_VERSION}& \macro{\_POSIX\_VERSION} &
+ \texttt{\_SC\_VERSION}& \const{\_POSIX\_VERSION} &
Indica il mese e l'anno di approvazione della revisione dello standard
POSIX.1 a cui il sistema fa riferimento, nel formato YYYYMML, la
revisione più recente è 199009L, che indica il Settembre 1990.\\
\textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{LINK\_MAX} &8 & numero massimo di link a un file\\
- \macro{NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
- \macro{PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
- \macro{PIPE\_BUF}&4096 & byte scrivibili atomicamente in una pipe
+ \const{LINK\_MAX} &8 & numero massimo di link a un file\\
+ \const{NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
+ \const{PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
+ \const{PIPE\_BUF}&4096 & byte scrivibili atomicamente in una pipe
(vedi \secref{sec:ipc_pipes}).\\
- \macro{MAX\_CANON}&255 & dimensione di una riga di terminale in modo
+ \const{MAX\_CANON}&255 & dimensione di una riga di terminale in modo
canonico (vedi \secref{sec:term_design}).\\
- \macro{MAX\_INPUT}&255 & spazio disponibile nella coda di input
+ \const{MAX\_INPUT}&255 & spazio disponibile nella coda di input
del terminale (vedi \secref{sec:term_design}).\\
\hline
\end{tabular}
\textbf{Macro}&\textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{\_POSIX\_LINK\_MAX} &8 & numero massimo di link a un file.\\
- \macro{\_POSIX\_NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
- \macro{\_POSIX\_PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
- \macro{\_POSIX\_PIPE\_BUF}& 512 & byte scrivibili atomicamente in una
+ \const{\_POSIX\_LINK\_MAX} &8 & numero massimo di link a un file.\\
+ \const{\_POSIX\_NAME\_MAX}& 14 & lunghezza in byte di un nome di file. \\
+ \const{\_POSIX\_PATH\_MAX}& 256 & lunghezza in byte di un pathname.\\
+ \const{\_POSIX\_PIPE\_BUF}& 512 & byte scrivibili atomicamente in una
pipe.\\
- \macro{\_POSIX\_MAX\_CANON}&255 & dimensione di una riga di
+ \const{\_POSIX\_MAX\_CANON}&255 & dimensione di una riga di
terminale in modo canonico.\\
- \macro{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
+ \const{\_POSIX\_MAX\_INPUT}&255 & spazio disponibile nella coda di input
del terminale.\\
-% \macro{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
-% \macro{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
-% \macro{\_POSIX\_FD\_SETSIZE}& 16 & \\
-% \macro{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
+% \const{\_POSIX\_MQ\_OPEN\_MAX}& 8& \\
+% \const{\_POSIX\_MQ\_PRIO\_MAX}& 32& \\
+% \const{\_POSIX\_FD\_SETSIZE}& 16 & \\
+% \const{\_POSIX\_DELAYTIMER\_MAX}& 32 & \\
\hline
\end{tabular}
\caption{Macro dei valori minimi delle caratteristiche dei file per la
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} assumerà il valore \macro{EFAULT}.}
+ fallimento, nel qual caso \var{errno} assumerà il valore \const{EFAULT}.}
\end{prototype}
La funzione, che viene usata dal comando \cmd{uname}, restituisce le
\end{itemize*}
l'ultima informazione è stata aggiunta di recente e non è prevista dallo
standard POSIX, essa è accessibile, come mostrato in \figref{fig:sys_utsname},
-solo definendo \macro{\_GNU\_SOURCE}.
+solo definendo \const{\_GNU\_SOURCE}.
\begin{figure}[!htb]
\footnotesize \centering
In generale si tenga presente che le dimensioni delle stringe di una
\var{utsname} non è specificata, e che esse sono sempre terminate con
-\macro{NULL}; il manuale delle \acr{glibc} indica due diverse dimensioni,
-\macro{\_UTSNAME\_LENGTH} per i campi standard e
-\macro{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
-altri sistemi usano nomi diversi come \macro{SYS\_NMLN} o \macro{\_SYS\_NMLN}
-o \macro{UTSLEN} che possono avere valori diversi.\footnote{Nel caso di Linux
+\val{null}; il manuale delle \acr{glibc} indica due diverse dimensioni,
+\const{\_UTSNAME\_LENGTH} per i campi standard e
+\const{\_UTSNAME\_DOMAIN\_LENGTH} per quello specifico per il nome di dominio;
+altri sistemi usano nomi diversi come \const{SYS\_NMLN} o \const{\_SYS\_NMLN}
+o \const{UTSLEN} che possono avere valori diversi.\footnote{Nel caso di Linux
\func{uname} corrisponde in realtà a 3 system call diverse, le prime due usano
rispettivamente delle lunghezze delle stringhe di 9 e 65 byte; la terza usa
anch'essa 65 byte, ma restituisce anche l'ultimo campo, \var{domainname}, con
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EPERM}] non si ha il permesso di accedere ad uno dei componenti
- nel cammino specificato per il parametro, o di accedere al parametro nella
- modalità scelta.
- \item[\macro{ENOTDIR}] non esiste un parametro corrispondente al nome
+ \item[\errcode{EPERM}] non si ha il permesso di accedere ad uno dei
+ componenti nel cammino specificato per il parametro, o di accedere al
+ parametro nella modalità scelta.
+ \item[\errcode{ENOTDIR}] non esiste un parametro corrispondente al nome
\param{name}.
-% \item[\macro{EFAULT}] si è specificato \param{oldlenp} zero quando
+% \item[\errcode{EFAULT}] si è specificato \param{oldlenp} zero quando
% \param{oldval} è non nullo.
- \item[\macro{EINVAL}] o si è specificato un valore non valido per il
+ \item[\errcode{EINVAL}] o si è specificato un valore non valido per il
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
+ \item[\errcode{ENOMEM}] talvolta viene usato più correttamente questo errore
quando non si è specificato sufficiente spazio per ricevere il valore di un
parametro.
\end{errlist}
- ed inoltre \macro{EFAULT}.
+ ed inoltre \const{EFAULT}.
}
\end{functions}
fallimento, nel qual caso gli errori comuni a tutti i filesystem che possono
essere restituiti in \var{errno} sono:
\begin{errlist}
- \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
- \item[\macro{ENODEV}] \param{filesystemtype} non esiste o non è configurato
+ \item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
+ \item[\errcode{ENODEV}] \param{filesystemtype} non esiste o non è configurato
nel kernel.
- \item[\macro{ENOTBLK}] non si è usato un \textit{block device} per
+ \item[\errcode{ENOTBLK}] non si è usato un \textit{block device} per
\param{source} quando era richiesto.
- \item[\macro{EBUSY}] \param{source} è già montato, o non può essere
+ \item[\errcode{EBUSY}] \param{source} è già montato, o non può essere
rimontato in read-only perché ci sono ancora file aperti in scrittura, o
\param{target} è ancora in uso.
- \item[\macro{EINVAL}] il device \param{source} presenta un
+ \item[\errcode{EINVAL}] il device \param{source} presenta un
\textit{superblock} non valido, o si è cercato di rimontare un filesystem
non ancora montato, o di montarlo senza che \param{target} sia un
\textit{mount point} o di spostarlo quando \param{target} non è un
\textit{mount point} o è \file{/}.
- \item[\macro{EACCES}] non si ha il permesso di accesso su uno dei componenti
- del pathname, o si è cercato di montare un filesystem disponibile in sola
- lettura senza averlo specificato o il device \param{source} è su un
- filesystem montato con l'opzione \macro{MS\_NODEV}.
- \item[\macro{ENXIO}] il \textit{major number} del device \param{source} è
+ \item[\errcode{EACCES}] non si ha il permesso di accesso su uno dei
+ componenti del pathname, o si è cercato di montare un filesystem
+ disponibile in sola lettura senza averlo specificato o il device
+ \param{source} è su un filesystem montato con l'opzione \const{MS\_NODEV}.
+ \item[\errcode{ENXIO}] il \textit{major number} del device \param{source} è
sbagliato.
- \item[\macro{EMFILE}] la tabella dei device \textit{dummy} è piena.
+ \item[\errcode{EMFILE}] la tabella dei device \textit{dummy} è piena.
\end{errlist}
- ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
- \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
+ ed inoltre \const{ENOTDIR}, \const{EFAULT}, \const{ENOMEM},
+ \const{ENAMETOOLONG}, \const{ENOENT} o \const{ELOOP}.}
\end{prototype}
La funzione monta sulla directory \param{target}, detta \textit{mount point},
In Linux \param{mountflags} deve essere un intero a 32 bit i cui 16 più
significativi sono un \textit{magic number}\footnote{cioè un numero speciale
usato come identificativo, che nel caso è \code{0xC0ED}; si può usare la
- costante \macro{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
+ costante \const{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 impostati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
+vanno impostati con un OR aritmetico della costante \const{MS\_MGC\_VAL} con i
valori riportati in \tabref{tab:sys_mount_flags}.
\begin{table}[htb]
\textbf{Parametro} & \textbf{Valore}&\textbf{Significato}\\
\hline
\hline
- \macro{MS\_RDONLY} & 1 & monta in sola lettura\\
- \macro{MS\_NOSUID} & 2 & ignora i bit \acr{suid} e \acr{sgid}\\
- \macro{MS\_NODEV} & 4 & impedisce l'accesso ai file di dispositivo\\
- \macro{MS\_NOEXEC} & 8 & impedisce di eseguire programmi \\
- \macro{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
- \macro{MS\_REMOUNT} & 32 & rimonta il filesystem cambiando i flag\\
- \macro{MS\_MANDLOCK} & 64 & consente il \textit{mandatory locking} (vedi
+ \const{MS\_RDONLY} & 1 & monta in sola lettura\\
+ \const{MS\_NOSUID} & 2 & ignora i bit \acr{suid} e \acr{sgid}\\
+ \const{MS\_NODEV} & 4 & impedisce l'accesso ai file di dispositivo\\
+ \const{MS\_NOEXEC} & 8 & impedisce di eseguire programmi \\
+ \const{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
+ \const{MS\_REMOUNT} & 32 & rimonta il filesystem cambiando i flag\\
+ \const{MS\_MANDLOCK} & 64 & consente il \textit{mandatory locking} (vedi
\secref{sec:file_mand_locking})\\
- \macro{S\_WRITE} & 128 & scrive normalmente \\
- \macro{S\_APPEND} & 256 & consente la scrittura solo in \textit{append
+ \const{S\_WRITE} & 128 & scrive normalmente \\
+ \const{S\_APPEND} & 256 & consente la scrittura solo in \textit{append
mode} (vedi \secref{sec:file_sharing})\\
- \macro{S\_IMMUTABLE} & 512 & impedisce che si possano modificare i file \\
- \macro{MS\_NOATIME} &1024 & non aggiorna gli \textit{access time} (vedi
+ \const{S\_IMMUTABLE} & 512 & impedisce che si possano modificare i file \\
+ \const{MS\_NOATIME} &1024 & non aggiorna gli \textit{access time} (vedi
\secref{sec:file_file_times})\\
- \macro{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
+ \const{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
directory\\
- \macro{MS\_BIND} &4096 & monta il filesystem altrove\\
- \macro{MS\_MOVE} &8192 & sposta atomicamente il punto di montaggio \\
+ \const{MS\_BIND} &4096 & monta il filesystem altrove\\
+ \const{MS\_MOVE} &8192 & sposta atomicamente il punto di montaggio \\
\hline
\end{tabular}
\caption{Tabella dei codici dei flag di montaggio di un 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 impostato specifica che
+bit di \param{mountflags}, \const{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.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
fallimento, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
- \item[\macro{EBUSY}] \param{target} è la directory di lavoro di qualche
+ \item[\errcode{EPERM}] il processo non ha i privilegi di amministratore.
+ \item[\errcode{EBUSY}] \param{target} è la directory di lavoro di qualche
processo, o contiene dei file aperti, o un altro mount point.
\end{errlist}
- ed inoltre \macro{ENOTDIR}, \macro{EFAULT}, \macro{ENOMEM},
- \macro{ENAMETOOLONG}, \macro{ENOENT} o \macro{ELOOP}.}
+ ed inoltre \const{ENOTDIR}, \const{EFAULT}, \const{ENOMEM},
+ \const{ENAMETOOLONG}, \const{ENOENT} o \const{ELOOP}.}
\end{prototype}
\noindent la funzione prende il nome della directory su cui il filesystem è
montato e non il file o il dispositivo che è stato montato,\footnote{questo è
\textsl{occupato}, questo avviene quando ci sono ancora file aperti sul
filesystem, se questo contiene la directory di lavoro corrente di un qualunque
processo o il mount point di un altro filesystem; in questo caso l'errore
-restituito è \macro{EBUSY}.
+restituito è \errcode{EBUSY}.
Linux provvede inoltre una seconda funzione, \func{umount2}, che in alcuni
casi permette di forzare lo smontaggio di un filesystem, anche quando questo
\end{prototype}
Il valore di \param{flags} è una maschera binaria, e al momento l'unico valore
-definito è il bit \macro{MNT\_FORCE}; gli altri bit devono essere nulli.
-Specificando \macro{MNT\_FORCE} la funzione cercherà di liberare il filesystem
+definito è il bit \const{MNT\_FORCE}; gli altri bit devono essere nulli.
+Specificando \const{MNT\_FORCE} la funzione cercherà di liberare il filesystem
anche se è occupato per via di una delle condizioni descritte in precedenza. A
seconda del tipo di filesystem alcune (o tutte) possono essere superate,
-evitando l'errore di \macro{EBUSY}. In tutti i casi prima dello smontaggio
+evitando l'errore di \errcode{EBUSY}. In tutti i casi prima dello smontaggio
viene eseguita una sincronizzazione dei dati.
Altre due funzioni specifiche di Linux,\footnote{esse si trovano anche su BSD,
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\macro{ENOSYS}] il filesystem su cui si trova il file specificato non
+ \item[\errcode{ENOSYS}] il filesystem su cui si trova il file specificato non
supporta la funzione.
\end{errlist}
- e \macro{EFAULT} ed \macro{EIO} per entrambe, \macro{EBADF} per
- \func{fstatfs}, \macro{ENOTDIR}, \macro{ENAMETOOLONG}, \macro{ENOENT},
- \macro{EACCES}, \macro{ELOOP} per \func{statfs}.}
+ e \const{EFAULT} ed \const{EIO} per entrambe, \const{EBADF} per
+ \func{fstatfs}, \const{ENOTDIR}, \const{ENAMETOOLONG}, \const{ENOENT},
+ \const{EACCES}, \const{ELOOP} per \func{statfs}.}
\end{functions}
Queste funzioni permettono di ottenere una serie di informazioni generali
Restituiscono le informazioni relative all'utente specificato.
\bodydesc{Le funzioni ritornano il puntatore alla struttura contenente le
- informazioni in caso di successo e \macro{NULL} nel caso non sia stato
+ informazioni in caso di successo e \val{null} nel caso non sia stato
trovato nessun utente corrispondente a quanto specificato.}
\end{functions}
\param{buflen} byte, sarà utilizzata per contenere le stringhe puntate dai
campi di \param{password}. Infine all'indirizzo puntato da \param{result}
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
+l'utente esista, o \val{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 impostato a
-\macro{NULL}).
+restituendo \errcode{ERANGE} (e \param{result} sarà comunque impostato a
+\val{null}).
Del tutto analoghe alle precedenti sono le funzioni \func{getgrnam} e
\func{getgrgid} (e le relative analoghe rientranti con la stessa estensione
\end{functions}
In caso questo non venga specificato nessun file viene usato il valore
-standard \macro{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
+standard \const{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
\func{utmpname} prevede due possibili valori:
\begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\macro{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
+\item[\const{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
correntemente collegati.
-\item[\macro{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
+\item[\const{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
storico degli utenti collegati.
\end{basedescript}
corrispondenti ai file \file{/var/run/utmp} e \file{/var/log/wtmp} visti in
Scrive una voce nel database.
\bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
- caso di successo e \macro{NULL} in caso di errore.}
+ caso di successo e \val{null} in caso di errore.}
\end{functions}
Tutte queste funzioni fanno riferimento ad una struttura di tipo \var{utmp},
Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
campo \var{ut\_type} dell'argomento \param{ut}. Questo può assumere i valori
riportati in \tabref{tab:sys_ut_type}, quando assume i valori
-\macro{RUN\_LVL}, \macro{BOOT\_TIME}, \macro{OLD\_TIME}, \macro{NEW\_TIME},
+\const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
verrà restituito la prima voce che corrisponde al tipo determinato; quando
-invece assume i valori \macro{INIT\_PROCESS}, \macro{LOGIN\_PROCESS},
-\macro{USER\_PROCESS} o \macro{DEAD\_PROCESS} verrà restituita la prima voce
+invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
+\const{USER\_PROCESS} o \const{DEAD\_PROCESS} verrà restituita la prima voce
corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
\begin{table}[htb]
\textbf{Funzione} & \textbf{Significato}\\
\hline
\hline
- \macro{EMPTY} & Non contiene informazioni valide. \\
- \macro{RUN\_LVL} & Identica il runlevel del sistema. \\
- \macro{BOOT\_TIME} & Identifica il tempo di avvio del sistema \\
- \macro{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
+ \const{EMPTY} & Non contiene informazioni valide. \\
+ \const{RUN\_LVL} & Identica il runlevel del sistema. \\
+ \const{BOOT\_TIME} & Identifica il tempo di avvio del sistema \\
+ \const{OLD\_TIME} & Identifica quando è stato modificato l'orologio di
sistema. \\
- \macro{NEW\_TIME} & Identifica da quanto è stato modificato il
+ \const{NEW\_TIME} & Identifica da quanto è stato modificato il
sistema. \\
- \macro{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}. \\
- \macro{LOGIN\_PROCESS}& Identifica un processo di login. \\
- \macro{USER\_PROCESS} & Identifica un processo utente. \\
- \macro{DEAD\_PROCESS} & Identifica un processo terminato. \\
- \macro{ACCOUNTING} & ??? \\
+ \const{INIT\_PROCESS} & Identifica un processo lanciato da \cmd{init}. \\
+ \const{LOGIN\_PROCESS}& Identifica un processo di login. \\
+ \const{USER\_PROCESS} & Identifica un processo utente. \\
+ \const{DEAD\_PROCESS} & Identifica un processo terminato. \\
+ \const{ACCOUNTING} & ??? \\
\hline
\end{tabular}
\caption{Classificazione delle voci del database di accounting a seconda dei
\end{table}
La funzione \func{getutline} esegue la ricerca sulle voci che hanno
-\var{ut\_type} uguale a \macro{LOGIN\_PROCESS} o \macro{USER\_PROCESS},
+\var{ut\_type} uguale a \const{LOGIN\_PROCESS} o \const{USER\_PROCESS},
restituendo la prima che corrisponde al valore di \var{ut\_line}, che
specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
terminale che interessa. Lo stesso criterio di ricerca è usato da
specificati.
\bodydesc{Le funzioni ritornano il puntatore ad una struttura \var{utmp} in
- caso di successo e \macro{NULL} in caso di errore.}
+ caso di successo e \val{null} in caso di errore.}
\end{functions}
La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
- nel qual caso \var{errno} può essere \macro{EINVAL} o \macro{EFAULT}.}
+ nel qual caso \var{errno} può essere \const{EINVAL} o \const{EFAULT}.}
\end{functions}
L'argomento \param{who} permette di specificare il processo di cui si vuole
leggere l'uso delle risorse; esso può assumere solo i due valori
-\macro{RUSAGE\_SELF} per indicare il processo corrente e
-\macro{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
+\const{RUSAGE\_SELF} per indicare il processo corrente e
+\const{RUSAGE\_CHILDREN} per indicare l'insieme dei processi figli di cui si è
ricevuto lo stato di terminazione.
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
errore, nel qual caso \var{errno} assumerà uno dei 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
+ \item[\errcode{EINVAL}] I valori per \param{resource} non sono validi.
+ \item[\errcode{EPERM}] Un processo senza i privilegi di amministratore ha
cercato di innalzare i propri limiti.
\end{errlist}
- ed \macro{EFAULT}.}
+ ed \const{EFAULT}.}
\end{functions}
Entrambe le funzioni permettono di specificare su quale risorsa si vuole
\textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{RLIMIT\_CPU} & Il massimo tempo di CPU che il processo può
+ \const{RLIMIT\_CPU} & Il massimo tempo di CPU che il processo può
usare. Il superamento del limite comporta
- l'emissione di un segnale di \macro{SIGXCPU}.\\
- \macro{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
+ l'emissione di un segnale di \const{SIGXCPU}.\\
+ \const{RLIMIT\_FSIZE} & La massima dimensione di un file che un processo
può usare. Se il processo cerca di scrivere
oltre questa dimensione riceverà un segnale di
- \macro{SIGXFSZ}.\\
- \macro{RLIMIT\_DATA} & La massima dimensione della memoria dati di un
+ \const{SIGXFSZ}.\\
+ \const{RLIMIT\_DATA} & La massima dimensione della memoria dati di un
processo. Il tentativo di allocare più memoria
causa il fallimento della funzione di
allocazione. \\
- \macro{RLIMIT\_STACK} & La massima dimensione dello stack del
+ \const{RLIMIT\_STACK} & La massima dimensione dello stack del
processo. Se il processo esegue operazioni che
estendano lo stack oltre questa dimensione
- riceverà un segnale di \macro{SIGSEGV}.\\
- \macro{RLIMIT\_CORE} & La massima dimensione di un file di \textit{core
+ riceverà un segnale di \const{SIGSEGV}.\\
+ \const{RLIMIT\_CORE} & La massima dimensione di un file di \textit{core
dump} creato da un processo. Nel caso le
dimensioni dovessero essere maggiori il file non
verrebbe generato.\footnotemark\\
- \macro{RLIMIT\_RSS} & L'ammontare massimo di memoria fisica dato al
+ \const{RLIMIT\_RSS} & L'ammontare massimo di memoria fisica dato al
processo. Il limite è solo una indicazione per
il kernel, qualora ci fosse un surplus di
memoria questa verrebbe assegnata.\\
- \macro{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
+ \const{RLIMIT\_NPROC} & Il numero massimo di processi che possono essere
creati sullo stesso user id. Se il limite viene
raggiunto \func{fork} fallirà con un
- \macro{EAGAIN}.\\
- \macro{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
+ \errcode{EAGAIN}.\\
+ \const{RLIMIT\_NOFILE} & Il numero massimo di file che il processo può
aprire. L'apertura di un ulteriore file fallirà
- con un errore \macro{EMFILE}.\\
- \macro{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
+ con un errore \errcode{EMFILE}.\\
+ \const{RLIMIT\_MEMLOCK}& L'ammontare massimo di memoria che può essere
bloccata (vedi \secref{sec:proc_mem_lock}).\\
- \macro{RLIMIT\_AS} & La dimensione massima di tutta la memoria che il
+ \const{RLIMIT\_AS} & La dimensione massima di tutta la memoria che il
processo può ottenere. Se il processo tenta di
allocarne di più funzioni come \func{brk},
\func{malloc} o \func{mmap} falliranno. \\
\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
+È inoltre definita la costante \const{RLIM\_INFINITY} che permette di
sbloccare l'uso di una risorsa, ma solo un processo con i privilegi di
amministratore può innalzare un limite al di sopra del valore corrente del
limite massimo. Si tenga conto infine che tutti i limiti vengono ereditati dal
standard la etichetta come obsoleta, mentre lo standard POSIX 1003.1-2001 la
ha eliminata. In Linux è implementata come una system call nelle architetture
in cui essa è necessaria, ed in genere restituisce il valore del simbolo
-\macro{PAGE\_SIZE} del kernel, anche se le versioni delle librerie del C
+\const{PAGE\_SIZE} del kernel, anche se le versioni delle librerie del C
precedenti le \acr{glibc} 2.1 implementavano questa funzione restituendo
sempre un valore statico.
\end{functions}
Queste funzioni sono equivalenti all'uso della funzione \func{sysconf}
-rispettivamente con i parametri \macro{\_SC\_PHYS\_PAGES} e
-\macro{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
+rispettivamente con i parametri \const{\_SC\_PHYS\_PAGES} e
+\const{\_SC\_AVPHYS\_PAGES}. La prima restituisce il numero totale di pagine
corrispondenti alla RAM della macchina; la seconda invece la memoria
effettivamente disponibile per i processi.
restituiscono il numero di processori della macchina (e quello dei processori
attivi); anche queste sono informazioni comunque ottenibili attraverso
\func{sysconf} utilizzando rispettivamente i parametri
-\macro{\_SC\_NPROCESSORS\_CONF} e \macro{\_SC\_NPROCESSORS\_ONLN}.
+\const{\_SC\_NPROCESSORS\_CONF} e \const{\_SC\_NPROCESSORS\_ONLN}.
Infine le \acr{glibc} riprendono da BSD la funzione \func{getloadavg} che
permette di ottenere il carico di processore della macchina, in questo modo è
Viene misurato in \textit{clock tick}. Un tempo questo corrispondeva al
numero di interruzioni effettuate dal timer di sistema, adesso lo standard
POSIX richiede che esso sia pari al valore della costante
- \macro{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000, qualunque
+ \const{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000, qualunque
sia la risoluzione reale dell'orologio di sistema e la frequenza delle
interruzioni del timer.\footnote{quest'ultima, come accennato in
- \secref{sec:proc_hierarchy}, è invece data dalla costante \macro{HZ}.} Il
+ \secref{sec:proc_hierarchy}, è invece data dalla costante \const{HZ}.} Il
dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi una
risoluzione del microsecondo. Il numero di tick al secondo può essere
ricavato anche attraverso \func{sysconf} (vedi \secref{sec:sys_sysconf}). Il
- vecchio simbolo \macro{CLK\_TCK} definito in \file{time.h} è ormai
+ vecchio simbolo \const{CLK\_TCK} definito in \file{time.h} è ormai
considerato obsoleto.
\end{description}
La funzione restituisce il tempo in tick, quindi se si vuole il tempo in
secondi occorre moltiplicare il risultato per la costante
-\macro{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
- POSIX richiede che \macro{CLOCKS\_PER\_SEC} sia definito pari a 1000000
+\const{CLOCKS\_PER\_SEC}.\footnote{le \acr{glibc} seguono lo standard ANSI C,
+ POSIX richiede che \const{CLOCKS\_PER\_SEC} sia definito pari a 1000000
indipendentemente dalla risoluzione del timer di sistema.} In genere
\type{clock\_t} viene rappresentato come intero a 32 bit, il che comporta un
valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
Legge il valore corrente del \textit{calendar time}.
\bodydesc{La funzione ritorna il valore del \textit{calendar time} in caso
- di successo e -1 in caso di errore, che può essere solo \macro{EFAULT}.}
+ di successo e -1 in caso di errore, che può essere solo \const{EFAULT}.}
\end{prototype}
\noindent dove \param{t}, se non nullo, deve essere l'indirizzo di una
variabile su cui duplicare il valore di ritorno.
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}.}
+ che può essere \const{EFAULT} o \const{EPERM}.}
\end{prototype}
\noindent dato che modificare l'ora ha un impatto su tutto il sistema
il cambiamento dell'orologio è una operazione privilegiata e questa funzione
può essere usata solo da un processo con i privilegi di amministratore,
-altrimenti la chiamata fallirà con un errore di \macro{EPERM}.
+altrimenti la chiamata fallirà con un errore di \errcode{EPERM}.
Data la scarsa precisione nell'uso di \type{time\_t} (che ha una risoluzione
massima di un secondo) quando si devono effettuare operazioni sui tempi di
\bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
caso di errore, nel qual caso \var{errno} può assumere i valori
- \macro{EINVAL} \macro{EFAULT} e per \func{settimeofday} anche
- \macro{EPERM}.}
+ \const{EINVAL} \const{EFAULT} e per \func{settimeofday} anche
+ \const{EPERM}.}
\end{functions}
Queste funzioni utilizzano una struttura di tipo \var{timeval}, la cui
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 impostato a \macro{NULL}.
+pertanto deve essere sempre impostato a \val{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 impostare l'ora è quella
-di usare la funzione \func{adjtime}, il cui prototipo è:
+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)}
Aggiusta del valore \param{delta} l'orologio di sistema.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} assumerà il valore \macro{EPERM}.}
+ errore, nel qual caso \var{errno} assumerà il valore \errcode{EPERM}.}
\end{prototype}
Questa funzione permette di avere un aggiustamento graduale del tempo di
\bodydesc{La funzione restituisce lo stato dell'orologio (un valore $>0$) in
caso di successo e -1 in caso di errore, nel qual caso \var{errno}
- assumerà i valori \macro{EFAULT}, \macro{EINVAL} ed \macro{EPERM}.}
+ assumerà i valori \const{EFAULT}, \const{EINVAL} ed \const{EPERM}.}
\end{prototype}
La funzione richiede una struttura di tipo \var{timex}, la cui definizione,
\textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
+ \const{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 & Imposta la differenze in frequenza
+ \const{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 & Imposta il valore massimo dell'errore
+ \const{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 & Imposta la stima dell'errore
+ \const{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
sul tempo, espresso in microsecondi
nel campo \var{esterror} di
\var{timex}.\\
- \macro{ADJ\_STATUS} & 0x0010 & Imposta alcuni
+ \const{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 & Imposta la larghezza di banda del PLL
- implementato dal kernel,
+ \const{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 & Imposta il valore dei tick del timer
+ \const{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&Imposta uno spostamento una tantum
+ \const{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum
dell'orologio secondo il valore del
campo \var{offset} simulando il
comportamento di \func{adjtime}.\\
\textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
- \macro{TIME\_INS} & 1 & insert leap second.\\
- \macro{TIME\_DEL} & 2 & delete leap second.\\
- \macro{TIME\_OOP} & 3 & leap second in progress.\\
- \macro{TIME\_WAIT} & 4 & leap second has occurred.\\
- \macro{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
+ \const{TIME\_OK} & 0 & L'orologio è sincronizzato.\\
+ \const{TIME\_INS} & 1 & insert leap second.\\
+ \const{TIME\_DEL} & 2 & delete leap second.\\
+ \const{TIME\_OOP} & 3 & leap second in progress.\\
+ \const{TIME\_WAIT} & 4 & leap second has occurred.\\
+ \const{TIME\_BAD} & 5 & L'orologio non è sincronizzato.\\
\hline
\end{tabular}
\caption{Possibili valori di ritorno di \func{adjtimex}.}
\tabref{tab:sys_adjtimex_return}. Un valore di -1 viene usato per riportare
un errore; al solito se si cercherà di modificare l'orologio di sistema
(specificando un \var{mode} diverso da zero) senza avere i privilegi di
-amministratore si otterrà un errore di \macro{EPERM}.
+amministratore si otterrà un errore di \errcode{EPERM}.
\subsection{La gestione delle date.}
dati naturali (ora e data), dato che essa consente anche di trattare la
gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
\var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
- \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
+ \acr{glibc}, che, quando è definita \const{\_BSD\_SOURCE}, hanno la forma in
\figref{fig:sys_tm_struct}.}
Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
Converte il \textit{broken-down time} in formato \type{time\_t}.
\bodydesc{Tutte le funzioni restituiscono un puntatore al risultato in caso
- di successo e \macro{NULL} in caso di errore, tranne che \func{mktime} che
+ di successo e \val{null} in caso di errore, tranne che \func{mktime} che
restituisce direttamente il valore o -1 in caso di errore.}
\end{functions}
\begin{verbatim}
"Wed Jun 30 21:49:08 1993\n"
\end{verbatim}
-e impostano anche la variabile \var{tzname} con l'informazione della \textit{time
- zone} corrente; \func{ctime} è banalmente definita in termini di
+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
sostitute rientranti, il cui nome è al solito ottenuto appendendo un
\end{prototype}
La funzione inizializza le variabili di \figref{fig:sys_tzname} a partire dal
-valore della variabile di ambiente \macro{TZ}, se quest'ultima non è definita
+valore della variabile di ambiente \const{TZ}, se quest'ultima non è definita
verrà usato il file \file{/etc/localtime}.
\begin{figure}[!htb]
In genere le funzioni di libreria usano un valore speciale per indicare che
c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
-costante \macro{EOF} (a seconda della funzione); ma questo valore segnala solo
-che c'è stato un errore, non il tipo di errore.
+costante \val{EOF} (a seconda della funzione); ma questo valore segnala solo
+che c'è stato un errore, non il tipo di errore.
Per riportare il tipo di errore il sistema usa la variabile globale
\var{errno},\footnote{L'uso di una variabile globale può comportare alcuni
\param{errnum}.
\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} assumerà il valore \macro{EINVAL} se si è specificato un
+ errore in caso di successo e \val{null} in caso di errore, nel qual caso
+ \var{errno} assumerà il valore \const{EINVAL} se si è specificato un
numero di errore non valido.}
\end{prototype}
In generale \func{strerror} viene usata passando \var{errno} come parametro;
nel caso si specifichi un codice sbagliato verrà restituito un messaggio di
-errore sconosciuto, e la funzione restituirà come errore \macro{EINVAL}. La
+errore sconosciuto, e la funzione restituirà come errore \errcode{EINVAL}. La
funzione tiene conto del valore della variabile di ambiente
-\macro{LC\_MESSAGES} per usare eventuali traduzioni dei messaggi d'errore
+\const{LC\_MESSAGES} per usare eventuali traduzioni dei messaggi d'errore
nella localizzazione presente.
La funzione utilizza una stringa statica che non deve essere modificata dal
(compreso il terminatore) \param{size}.
\bodydesc{La funzione restituisce il puntatore alla stringa; in caso di
- errore \var{errno} oltre a \macro{EINVAL} può assumere anche il valore
- \macro{ERANGE} per indicare che non c'è sufficiente memoria per contenere
+ errore \var{errno} oltre a \const{EINVAL} può assumere anche il valore
+ \const{ERANGE} per indicare che non c'è sufficiente memoria per contenere
la stringa di descrizione.}
\end{prototype}
\noindent
problemi connessi alla condivisione del buffer statico. La funzione
restituisce l'indirizzo della stringa usata, che può essere contenuta nel
buffer specificato da \param{buf}, per una lunghezza non superiore a
-\param{size}, nel qual caso la stringa sarebbe troncata e terminata con
-\macro{NUL}.
+\param{size}, nel qual caso la stringa sarebbe troncata e terminata con uno
+zero (il carattere NUL).
Una seconda funzione usata per riportare i codici di errore in maniera
projects / gapil.git / commitdiff