Inseriti commenti ad alcune direttive C e corretta la definizione di

Signal

diff --git a/intro.tex b/intro.tex
index 049d516d9bda31d8675a18410dd7e80a183cfc40..e349fe678271fbaea6d618fe4f6d746a97f35ab4 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{table}[htb]
   \footnotesize
   \centering

-  \begin{tabular}[c]{|l|c|c|l|}
+  \begin{tabular}[c]{|l|l|}

     \hline
     \textbf{Tipo} & \textbf{Contenuto} \\
     \hline
     \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{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.\\
     \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 a3846faf6ff3bba8f19f8ce20a903bf6ef4373f2..270113c21792b3bea832acfc24279a8c5c388d4d 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
 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
 
 Chiamare \func{MutexLock} decrementa il valore del semaforo: se questo è
 libero (ha già valore 1) sarà bloccato (valore nullo), se è bloccato la

diff --git a/macro.tex b/macro.tex
index 699281359e1ae05f35bf822d8b151716c11c890c..301fb8e4ad02e1220375b9f78a75cff154c4233d 100644 (file)
--- a/macro.tex
+++ b/macro.tex
@@ -124,6 +124,9 @@
 \newcommand{\const}[1]{%
 \index{#1@{{\tt {#1}} (costante)}}\texttt{#1}%
 }                                     % constant name
 \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
 \newcommand{\file}[1]{\texttt{#1}}    % file name
 \newcommand{\link}[1]{\texttt{#1}}    % html link
 \newcommand{\ctyp}[1]{\texttt{#1}}    % C standard type

diff --git a/process.tex b/process.tex
index bf022ee9174a6f9bd9ba5416d5ab48028aa042cf..3069d292982dddf97840eb29484c09a5d403ca41 100644 (file)
--- a/process.tex
+++ b/process.tex
@@ -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
 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
 
 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
 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).}.

 
 
 
 
 
 

diff --git a/prochand.tex b/prochand.tex
index f3be05d046d07ced136a269ad9d1319765d50651..f17fec4cdfd073dd99e61880f9ed80954f3cc6c7 100644 (file)
--- a/prochand.tex
+++ b/prochand.tex
@@ -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
 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.
 
 
 condiviso, onde evitare problemi con le ottimizzazioni del codice.
 
 

diff --git a/signal.tex b/signal.tex
index 0b497d8033b5052347507c3b6c1c7d3d2d0a9b5c..755f19c2cf6385d237fc22b0c3f7d2604f5213fe 100644 (file)
--- a/signal.tex
+++ b/signal.tex
@@ -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,
 
 % In questo caso si è tratterà di illustrare un esempio relativo ad un
 % gestore per che è previsto ritornare,
 

-

 \begin{figure}[!htb]
   \footnotesize 
   \begin{lstlisting}{}
 \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;
 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;
 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 */
     /* 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 */
     /* 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);
 }
     }
     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
 \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}}
 
 \subsection{La gestione della \textsl{maschera dei segnali} o 
   \textit{signal mask}}

diff --git a/sources/SigHand.c b/sources/SigHand.c
index 53d185a08f50be41176c66ac1683fa2c2e840b0e..6b2cf95cf338ba4ae74ed25692c05b01f35aa362 100644 (file)
--- a/sources/SigHand.c
+++ b/sources/SigHand.c
@@ -22,7 +22,7 @@
  *
  * Author: S. Piccardi Dec. 2002
  *
  *
  * 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 */
  *
  *****************************************************************************/
 #include <errno.h>                               /* error simbol definitions */


@@ -49,17 +49,15 @@
 inline SigFunc * Signal(int signo, SigFunc *func) 
 {
     struct sigaction new_handl, old_handl;
 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 */
     /* 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)){ 
     /* 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);
 }
     }
     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
  * 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)
 {
  */
 void HandSigCHLD(int sig)
 {

diff --git a/system.tex b/system.tex
index 40172df1e56fb0897bac9a9be9fb46977f6a45de..ec2f1b6a14fc0df116a0c36bc1fddfc5fc52616e 100644 (file)
--- a/system.tex
+++ b/system.tex
@@ -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
   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},
 normale.
 
 I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},