Inseriti commenti ad alcune direttive C e corretta la definizione di
authorSimone Piccardi <piccardi@gnulinux.it>
Wed, 11 Dec 2002 00:51:38 +0000 (00:51 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Wed, 11 Dec 2002 00:51:38 +0000 (00:51 +0000)
Signal

intro.tex
ipc.tex
macro.tex
process.tex
prochand.tex
signal.tex
sources/SigHand.c
system.tex

index 049d516..e349fe6 100644 (file)
--- a/intro.tex
+++ b/intro.tex
@@ -378,7 +378,7 @@ tipi si sono rivelati inadeguati, e se ne 
 \begin{table}[htb]
   \footnotesize
   \centering
-  \begin{tabular}[c]{|l|c|c|l|}
+  \begin{tabular}[c]{|l|l|}
     \hline
     \textbf{Tipo} & \textbf{Contenuto} \\
     \hline
@@ -396,8 +396,8 @@ tipi si sono rivelati inadeguati, e se ne 
     \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.\\
diff --git a/ipc.tex b/ipc.tex
index a3846fa..270113c 100644 (file)
--- a/ipc.tex
+++ b/ipc.tex
@@ -2564,22 +2564,7 @@ il mutex. Entrambe fanno da wrapper per \func{semop}, utilizzando le due
 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
index 6992813..301fb8e 100644 (file)
--- a/macro.tex
+++ b/macro.tex
 \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
index bf022ee..3069d29 100644 (file)
@@ -1569,8 +1569,16 @@ Uno dei punti critici dei salti non-locali 
 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
@@ -1579,7 +1587,13 @@ chiamata ad un'altra funzioni vengono salvati nel contesto nello stack)
 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).}.
 
 
 
index f3be05d..f17fec4 100644 (file)
@@ -2436,7 +2436,7 @@ assumere che, in ogni piattaforma su cui 
 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.
 
 
index 0b497d8..755f19c 100644 (file)
@@ -1409,16 +1409,9 @@ di zombie\index{zombie}.
 % 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;
@@ -1963,17 +1956,15 @@ typedef void SigFunc(int);
 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);
 }
@@ -1985,10 +1976,29 @@ inline SigFunc * Signal(int signo, SigFunc *func)
 \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}}
index 53d185a..6b2cf95 100644 (file)
@@ -22,7 +22,7 @@
  *
  * 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);
 }
@@ -68,7 +66,7 @@ inline SigFunc * Signal(int signo, SigFunc *func)
  * 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)
 {
index 40172df..ec2f1b6 100644 (file)
@@ -2344,11 +2344,11 @@ Per riportare il tipo di errore il sistema usa la variabile globale
   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},