Correzioni sulle chiamate

[gapil.git] / ipc.tex

diff --git a/ipc.tex b/ipc.tex
index 4613f8d912cdb0b9d81e4ee8dd5a65f1002906d3..2e4d3811119702c993539b5554b91e0f29e638e9 100644 (file)
--- a/ipc.tex
+++ b/ipc.tex
@@ -3085,10 +3085,10 @@ int ComputeValues(struct dirent * direntry)
     if (S_ISREG(data.st_mode)) shmptr->tot_regular++;
     if (S_ISFIFO(data.st_mode)) shmptr->tot_fifo++;
     if (S_ISLNK(data.st_mode)) shmptr->tot_link++;
     if (S_ISREG(data.st_mode)) shmptr->tot_regular++;
     if (S_ISFIFO(data.st_mode)) shmptr->tot_fifo++;
     if (S_ISLNK(data.st_mode)) shmptr->tot_link++;

-    if (S_ISDIR(data.st_mode)) shmptr->tot_dir;
-    if (S_ISBLK(data.st_mode)) shmptr->tot_block;
-    if (S_ISCHR(data.st_mode)) shmptr->tot_char;
-    if (S_ISSOCK(data.st_mode)) shmptr->tot_sock;
+    if (S_ISDIR(data.st_mode)) shmptr->tot_dir++;
+    if (S_ISBLK(data.st_mode)) shmptr->tot_block++;
+    if (S_ISCHR(data.st_mode)) shmptr->tot_char++;
+    if (S_ISSOCK(data.st_mode)) shmptr->tot_sock++;

     return 0;
 }
 /*
     return 0;
 }
 /*


@@ -3186,8 +3186,6 @@ int main(int argc, char *argv[])
     }
     /* main loop */
     MutexLock(mutex);                                  /* lock shared memory */
     }
     /* main loop */
     MutexLock(mutex);                                  /* lock shared memory */

-    printf("File presenti %d file, per un totale di %d byte\n",
-           shmptr->tot_files, shmptr->tot_size);

     printf("Ci sono %d file dati\n", shmptr->tot_regular);
     printf("Ci sono %d directory\n", shmptr->tot_dir);
     printf("Ci sono %d link\n", shmptr->tot_link);
     printf("Ci sono %d file dati\n", shmptr->tot_regular);
     printf("Ci sono %d directory\n", shmptr->tot_dir);
     printf("Ci sono %d link\n", shmptr->tot_link);


@@ -3195,6 +3193,8 @@ int main(int argc, char *argv[])
     printf("Ci sono %d socket\n", shmptr->tot_sock);
     printf("Ci sono %d device a caratteri\n", shmptr->tot_char);
     printf("Ci sono %d device a blocchi\n", shmptr->tot_block);
     printf("Ci sono %d socket\n", shmptr->tot_sock);
     printf("Ci sono %d device a caratteri\n", shmptr->tot_char);
     printf("Ci sono %d device a blocchi\n", shmptr->tot_block);

+    printf("Totale  %d file, per %d byte\n",
+           shmptr->tot_files, shmptr->tot_size);

     MutexUnlock(mutex);                              /* unlock shared memory */
 }
     \end{lstlisting}
     MutexUnlock(mutex);                              /* unlock shared memory */
 }
     \end{lstlisting}


@@ -3220,6 +3220,10 @@ mutex (qui avviene il blocco se la memoria condivisa non 
 (\texttt{\small 32--40}) si stampano i vari valori in essa contenuti. Infine
 (\texttt{\small 41}) si rilascia il mutex. 
 
 (\texttt{\small 32--40}) si stampano i vari valori in essa contenuti. Infine
 (\texttt{\small 41}) si rilascia il mutex. 
 

+Verifichiamo allora il funzionamento del nostro programma
+
+
+

 
 %% Per capire meglio il funzionamento delle funzioni facciamo ancora una volta
 %% riferimento alle strutture con cui il kernel implementa i segmenti di memoria
 
 %% Per capire meglio il funzionamento delle funzioni facciamo ancora una volta
 %% riferimento alle strutture con cui il kernel implementa i segmenti di memoria


@@ -3458,41 +3462,63 @@ usano i semafori, anche se le due interfacce non possono essere completamente
 equivalenti, specie per quanto riguarda la rimozione del mutex.
 
 La prima funzione (\texttt{\small 1--5}) è \func{CreateMutex}, e serve a
 equivalenti, specie per quanto riguarda la rimozione del mutex.
 
 La prima funzione (\texttt{\small 1--5}) è \func{CreateMutex}, e serve a

-creare il mutex; la funzione è estremamente semplice, si limita
+creare il mutex; la funzione è estremamente semplice, e si limita

 (\texttt{\small 4}) a creare, con una opportuna chiamata ad \func{open}, il
 file che sarà usato per il successivo file locking, assicurandosi che non
 esista già (nel qual caso segnala un errore); poi restituisce il file
 descriptor che sarà usato dalle altre funzioni per acquisire e rilasciare il
 (\texttt{\small 4}) a creare, con una opportuna chiamata ad \func{open}, il
 file che sarà usato per il successivo file locking, assicurandosi che non
 esista già (nel qual caso segnala un errore); poi restituisce il file
 descriptor che sarà usato dalle altre funzioni per acquisire e rilasciare il

-mutex.  
+mutex.

 
 La seconda funzione (\texttt{\small 6--10}) è \func{FindMutex}, che, come la
 
 La seconda funzione (\texttt{\small 6--10}) è \func{FindMutex}, che, come la

-precedente, si è definita solo per mantenere una analogia con l'analoga
-funzione basata sui semafori, anch'essa si limita (\texttt{\small 9}) ad
+precedente, è stata definita per mantenere una analogia con la corrispondente
+funzione basata sui semafori. Anch'essa si limita (\texttt{\small 9}) ad

 aprire il file da usare per il file locking, solo che in questo caso le
 opzioni di \func{open} sono tali che il file in questione deve esistere di
 già.
 
 La terza funzione (\texttt{\small 11--23}) è \func{LockMutex} e serve per
 aprire il file da usare per il file locking, solo che in questo caso le
 opzioni di \func{open} sono tali che il file in questione deve esistere di
 già.
 
 La terza funzione (\texttt{\small 11--23}) è \func{LockMutex} e serve per

-acquisire il mutex. La funzione definisce (\texttt{\small 14} e inizializza
-(\texttt{\small 17--20}) la struttura \var{lock} per poter acquisire un write
-lock sul file, che poi (\texttt{\small 21}) viene richiesto con \func{fcntl}
-(restituendo il codice di ritorno). Se il file è libero il lock è acquisito e
-la funzione ritorna immediatamente; altrimenti \func{fcntl} si bloccherà (si
-noti che la si è chiamata con \func{F\_SETLKW}) fino al rilascio del lock.
+acquisire il mutex. La funzione definisce (\texttt{\small 14}) e inizializza
+(\texttt{\small 17--20}) la struttura \var{lock} da usare per acquisire un
+write lock sul file, che poi (\texttt{\small 21}) viene richiesto con
+\func{fcntl}, restituendo il valore di ritorno di quest'ultima. Se il file è
+libero il lock viene acquisito e la funzione ritorna immediatamente;
+altrimenti \func{fcntl} si bloccherà (si noti che la si è chiamata con
+\func{F\_SETLKW}) fino al rilascio del lock.

 
 La quarta funzione (\texttt{\small 24--35}) è \func{UnlockMutex} e serve a
 rilasciare il mutex. La funzione è analoga alla precedente, solo che in questo
 caso si inizializza (\texttt{\small 29--32}) la struttura \var{lock} per il
 rilascio del lock, che viene effettuato (\texttt{\small 34}) con la opportuna
 
 La quarta funzione (\texttt{\small 24--35}) è \func{UnlockMutex} e serve a
 rilasciare il mutex. La funzione è analoga alla precedente, solo che in questo
 caso si inizializza (\texttt{\small 29--32}) la struttura \var{lock} per il
 rilascio del lock, che viene effettuato (\texttt{\small 34}) con la opportuna

-chiamata a \func{fcntl}.
+chiamata a \func{fcntl}. Avendo usato il file locking in semantica POSIX (si
+riveda quanto detto \secref{sec:file_posix_lock}) solo il processo che ha
+precedentemente eseguito il lock può sbloccare il mutex.

 
 

-La quinta funzione \texttt{\small 36--40}) è \func{RemoveMutex} e serve a
-cancellare il mutex. Anche questa funzione è definita per mantenere una
+La quinta funzione (\texttt{\small 36--40}) è \func{RemoveMutex} e serve a
+cancellare il mutex. Anche questa funzione è stata definita per mantenere una

 analogia con le funzioni basate sui semafori, e si limita a cancellare
 analogia con le funzioni basate sui semafori, e si limita a cancellare

-\texttt{\small 39}) il file con una chiamata ad \func{unlink}. Si noti che in
-questo caso la funzione non ha effetto sui mutex già ottenuti, con precedenti
+(\texttt{\small 39}) il file con una chiamata ad \func{unlink}. Si noti che in
+questo caso la funzione non ha effetto sui mutex già ottenuti con precedenti

 chiamate a \func{FindMutex} o \func{CreateMutex}, che continueranno ad essere
 chiamate a \func{FindMutex} o \func{CreateMutex}, che continueranno ad essere

-disponibili fintanto che i relativi file descriptor saranno aperti.
+disponibili fintanto che i relativi file descriptor restano aperti. Pertanto
+per rilasciare un mutex occorrerà prima chiamare \func{UnlockMutex} oppure
+chiudere il file usato per il lock.
+
+La sesta funzione (\texttt{\small 41--56}) è \func{ReadMutex} e serve a
+leggere lo stato del mutex. In questo caso si prepara (\texttt{\small 47--50})
+la solita struttura \var{lock} come l'acquisizione del lock, ma si effettua
+(\texttt{\small 52}) la chiamata a \func{fcntl} usando il comando
+\const{F\_GETLK} per ottenere lo stato del lock, e si restituisce
+(\texttt{\small 53}) il valore di ritorno in caso di errore, ed il valore del
+campo \var{l\_type} (che descrive lo stato del lock) altrimenti. Per questo
+motivo la funzione restituirà -1 in caso di errore e uno dei due valori
+\const{F\_UNLCK} o \const{F\_WRLCK}\footnote{non si dovrebbe mai avere il
+  terzo valore possibile, \const{F\_RDLCK}, dato che la nostra interfaccia usa
+  solo i write lock. Però è sempre possibile che siano richiesti altri lock
+  sul file al di fuori dell'interfaccia, nel qual caso si potranno avere,
+  ovviamente, interferenze indesiderate.} ) in caso di successo, ed indicare
+che il mutex è, rispettivamente libero o occupato.
+
+

 
 Basandosi sulla semantica dei file lock POSIX valgono tutte le precisazioni
 relative al comportamento di questi ultimi fatte in
 
 Basandosi sulla semantica dei file lock POSIX valgono tutte le precisazioni
 relative al comportamento di questi ultimi fatte in