\begin{table}[htb]
\footnotesize
\centering
- \begin{tabular}[c]{|l|c|c|l|}
+ \begin{tabular}[c]{|l|l|}
\hline
\textbf{Tipo} & \textbf{Contenuto} \\
\hline
\type{pid\_t} & Identificatore di un processo.\\
\type{rlim\_t} & Limite sulle risorse.\\
\type{sigset\_t}& Insieme di segnali.\\
- \type{ssize\_t} & Dimensione di un oggetto.\\
- \type{ssize\_t} & Dimensione in numero byte ritornata dalle funzioni.\\
+ \type{size\_t} & Dimensione di un oggetto.\\
+ \type{ssize\_t} & Dimensione in numero di byte ritornata dalle funzioni.\\
\type{ptrdiff\_t}& Differenza fra due puntatori.\\
\type{time\_t} & Numero di secondi (in tempo di calendario).\\
\type{uid\_t} & Identificatore di un utente.\\
strutture \var{sem\_lock} e \var{sem\_unlock} definite in precedenza
(\texttt{\small 32--42}). Si noti come per queste ultime si sia fatto uso
dell'opzione \const{SEM\_UNDO} per evitare che il semaforo resti bloccato in
-caso di terminazione imprevista del processo.%% Si noti infine come, essendo
-%% tutte le funzioni riportate in \figref{fig:ipc_mutex_create} estremamente
-%% semplici, se si sono definite tutte come \ctyp{inline}.\footnote{la direttiva
-%% \func{inline} viene usata per dire al compilatore di non trattare la
-%% funzione cui essa fa riferimento come una funzione, ma di inserire il codice
-%% direttamente nel testo del programma. Anche se i compilatori più moderni
-%% sono in grado di effettuare da soli queste manipolazioni (impostando le
-%% opportune ottimizzazioni) questa è una tecnica usata per migliorare le
-%% prestazioni per le funzioni piccole ed usate di frequente, in tal caso
-%% infatti le istruzioni per creare un nuovo frame nello stack per chiamare la
-%% funzione costituirebbero una parte rilevante del codice, appesantendo
-%% inutilmente il programma. Originariamente questa era fatto utilizzando delle
-%% macro, ma queste hanno tutta una serie di problemi di sintassi nel passaggio
-%% degli argomenti (si veda ad esempio \cite{PratC} che in questo modo possono
-%% essere evitati.}
-
+caso di terminazione imprevista del processo.
Chiamare \func{MutexLock} decrementa il valore del semaforo: se questo è
libero (ha già valore 1) sarà bloccato (valore nullo), se è bloccato la
\newcommand{\const}[1]{%
\index{#1@{{\tt {#1}} (costante)}}\texttt{#1}%
} % constant name
+\newcommand{\direct}[1]{%
+\index{#1@{{\tt {#1}} (direttiva)}}\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
variabili, ed in particolare quello delle variabili automatiche della funzione
a cui si ritorna. In generale le variabili globali e statiche mantengono i
valori che avevano al momento della chiamata di \func{longjmp}, ma quelli
-delle variabili automatiche (o di quelle dichiarate \code{register}) sono in
-genere indeterminati.
+delle variabili automatiche (o di quelle dichiarate
+\direct{register}\footnote{la direttiva \direct{register} del compilatore
+ chiede che la variabile dichiarata tale sia mantenuta, nei limiti del
+ possibile, all'interno di un registro del processore. Questa direttiva
+ origina dai primi compilatori, quando stava al programmatore scrivere codice
+ ottimizzato, riservando esplicitamente alle variabili più usate l'uso dei
+ registri del processore. Oggi questa direttiva oggi è in disuso dato che
+ tutti i compilatori sono normalmente in grado di valutare con maggior
+ efficacia degli stessi programmatori quando sia il caso di eseguire questa
+ ottimizzazione.}) sono in genere indeterminati.
Quello che succede infatti è che i valori delle variabili che sono tenute in
memoria manterranno il valore avuto al momento della chiamata di
torneranno al valore avuto al momento della chiamata di \func{setjmp}; per
questo quando si vuole avere un comportamento coerente si può bloccare
l'ottimizzazione che porta le variabili nei registri dichiarandole tutte come
-\code{volatile}.
+\direct{volatile}\footnote{la direttiva \ctyp{volatile} informa il compilatore
+ che la variabile che è dichiarata può essere modificata, durante
+ l'esecuzione del nostro, da altri programmi. Per questo motivo occorre dire
+ al compilatore che non deve essere mai utilizzata l'ottimizzazione per cui
+ quanto opportuno essa viene mantenuta in un registro, poiché in questo modo
+ si perderebbero le eventuali modifiche fatte dagli altri programmi (che
+ avvengono solo in una copia posta in memoria).}.
atomici. Non è affatto detto che lo stesso valga per interi di dimensioni
maggiori (in cui l'accesso può comportare più istruzioni in assembler) o per
le strutture. In tutti questi casi è anche opportuno marcare come
-\ctyp{volatile} le variabili che possono essere interessate ad accesso
+\direct{volatile} le variabili che possono essere interessate ad accesso
condiviso, onde evitare problemi con le ottimizzazioni del codice.
% In questo caso si è tratterà di illustrare un esempio relativo ad un
% gestore per che è previsto ritornare,
-
\begin{figure}[!htb]
\footnotesize
\begin{lstlisting}{}
-#include <errno.h> /* error symbol definitions */
-#include <signal.h> /* signal handling declarations */
-#include <sys/types.h>
-#include <sys/wait.h>
-#include "macro.h"
-
void HandSigCHLD(int sig)
{
int errno_save;
inline SigFunc * Signal(int signo, SigFunc *func)
{
struct sigaction new_handl, old_handl;
- new_handl.sa_handler=func;
+ new_handl.sa_handler = func;
/* clear signal mask: no signal blocked during execution of func */
- if (sigemptyset(&new_handl.sa_mask)!=0){ /* initialize signal set */
- perror("cannot initializes the signal set to empty"); /* see mess. */
- exit(1);
+ if (sigemptyset(&new_handl.sa_mask)!=0){ /* initialize signal set */
+ return SIG_ERR;
}
- new_handl.sa_flags=0; /* init to 0 all flags */
+ new_handl.sa_flags=0; /* init to 0 all flags */
/* change action for signo signal */
- if (sigaction(signo,&new_handl,&old_handl)){
- perror("sigaction failed on signal action setting");
- exit(1);
+ if (sigaction(signo, &new_handl, &old_handl)){
+ return SIG_ERR;
}
return (old_handl.sa_handler);
}
\end{figure}
Per questo motivo si è provveduto, per mantenere un'interfaccia semplificata
-che abbia le stesse caratteristiche di \func{signal}, a definire una funzione
-equivalente attraverso \func{sigaction}; la funzione è \code{Signal}, e si
-trova definita nel file \file{SigHand.c} (nei sorgenti allegati), e riportata
-in \figref{fig:sig_Signal_code}. La riutilizzeremo spesso in seguito.
+che abbia le stesse caratteristiche di \func{signal}, a definire attraverso
+\func{sigaction} una funzione equivalente, il cui codice è riportato in
+\figref{fig:sig_Signal_code} (il codice completo si trova nel file
+\file{SigHand.c} nei sorgenti allegati). Si noti come, essendo la funzione
+estremamente semplice, è definita come \direct{inline}.\footnote{la direttiva
+ \direct{inline} viene usata per dire al compilatore di trattare la funzione
+ cui essa fa riferimento in maniera speciale inserendo il codice direttamente
+ nel testo del programma. Anche se i compilatori più moderni sono in grado
+ di effettuare da soli queste manipolazioni (impostando le opportune
+ ottimizzazioni) questa è una tecnica usata per migliorare le prestazioni per
+ le funzioni piccole ed usate di frequente (in particolare nel kernel, dove
+ in certi casi le ottimizzazioni dal compilatore, tarate per l'uso in user
+ space, non sono sempre adatte). In tal caso infatti le istruzioni per creare
+ un nuovo frame nello stack per chiamare la funzione costituirebbero una
+ parte rilevante del codice, appesantendo inutilmente il programma.
+ Originariamente questo comportamento veniva ottenuto con delle macro, ma
+ queste hanno tutta una serie di problemi di sintassi nel passaggio degli
+ argomenti (si veda ad esempio \cite{PratC}) che in questo modo possono
+ essere evitati.}
+
+
+
+
\subsection{La gestione della \textsl{maschera dei segnali} o
\textit{signal mask}}
*
* Author: S. Piccardi Dec. 2002
*
- * $Id: SigHand.c,v 1.2 2002/12/03 22:30:11 piccardi Exp $
+ * $Id: SigHand.c,v 1.3 2002/12/11 00:51:38 piccardi Exp $
*
*****************************************************************************/
#include <errno.h> /* error simbol definitions */
inline SigFunc * Signal(int signo, SigFunc *func)
{
struct sigaction new_handl, old_handl;
- new_handl.sa_handler=func;
+ new_handl.sa_handler = func; /* set signal handler */
/* clear signal mask: no signal blocked during execution of func */
- if (sigemptyset(&new_handl.sa_mask)!=0){ /* initialize signal set */
- perror("cannot initializes the signal set to empty"); /* see mess. */
- exit(1);
+ if (sigemptyset(&new_handl.sa_mask)!=0){ /* initialize signal set */
+ return SIG_ERR;
}
- new_handl.sa_flags=0; /* init to 0 all flags */
+ new_handl.sa_flags=0; /* init to 0 all flags */
/* change action for signo signal */
if (sigaction(signo,&new_handl,&old_handl)){
- perror("sigaction failed on signal action setting");
- exit(1);
+ return SIG_ERR;
}
return (old_handl.sa_handler);
}
* Generic handler for SIGCHLD signal
*
* Simone Piccardi Dec. 2002
- * $Id: SigHand.c,v 1.2 2002/12/03 22:30:11 piccardi Exp $
+ * $Id: SigHand.c,v 1.3 2002/12/11 00:51:38 piccardi Exp $
*/
void HandSigCHLD(int sig)
{
anche di definire \var{errno} come un \textit{modifiable lvalue}, quindi si
può anche usare una macro, e questo è infatti il modo usato da Linux per
renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
-variabile è in genere definita come \ctyp{volatile} dato che può essere
-cambiata in modo asincrono da un segnale (si veda \ref{sec:sig_sigchld} per un
-esempio, ricordando quanto trattato in \ref{sec:proc_race_cond}), ma dato che
-un manipolatore di segnale scritto bene salva e ripristina il valore della
-variabile, di questo non è necessario preoccuparsi nella programmazione
+variabile è in genere definita come \direct{volatile} dato che può essere
+cambiata in modo asincrono da un segnale (si veda \secref{sec:sig_sigchld} per
+un esempio, ricordando quanto trattato in \secref{sec:proc_race_cond}), ma
+dato che un manipolatore di segnale scritto bene salva e ripristina il valore
+della variabile, di questo non è necessario preoccuparsi nella programmazione
normale.
I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
projects / gapil.git / commitdiff