%% ipc.tex
%%
-%% Copyright (C) 2000-2015 Simone Piccardi. Permission is granted to
+%% Copyright (C) 2000-2024 Simone Piccardi. Permission is granted to
%% copy, distribute and/or modify this document under the terms of the GNU Free
%% Documentation License, Version 1.1 or any later version published by the
%% Free Software Foundation; with the Invariant Sections being "Un preambolo",
\end{figure}
Della funzione di sistema esiste una seconda versione, \funcd{pipe2},
-introdotta con il kernel 2.6.27 e le \acr{glibc} 2.9 e specifica di Linux
+introdotta con il kernel 2.6.27 e la \acr{glibc} 2.9 e specifica di Linux
(utilizzabile solo definendo la macro \macro{\_GNU\_SOURCE}), che consente di
impostare atomicamente le caratteristiche dei file descriptor restituiti, il
suo prototipo è:
\cmd{gs}, il primo infatti è in grado di generare immagini PostScript di
codici a barre corrispondenti ad una qualunque stringa, mentre il secondo
serve per poter effettuare la conversione della stessa immagine in formato
-JPEG. Usando una \textit{pipe} potremo inviare l'output del primo sull'input del
-secondo, secondo lo schema mostrato in fig.~\ref{fig:ipc_pipe_use}, in cui la
-direzione del flusso dei dati è data dalle frecce continue.
+JPEG. Usando una \textit{pipe} potremo inviare l'output del primo sull'input
+del secondo, secondo lo schema mostrato in fig.~\ref{fig:ipc_pipe_use}, in cui
+la direzione del flusso dei dati è data dalle frecce continue.
Si potrebbe obiettare che sarebbe molto più semplice salvare il risultato
intermedio su un file temporaneo. Questo però non tiene conto del fatto che un
\textit{pipe} creata, che sarà aperto in sola lettura (e quindi associato allo
\textit{standard output} del programma indicato) in caso si sia indicato
\code{r}, o in sola scrittura (e quindi associato allo \textit{standard
- input}) in caso di \code{w}. A partire dalla versione 2.9 delle \acr{glibc}
+ input}) in caso di \code{w}. A partire dalla versione 2.9 della \acr{glibc}
(questa è una estensione specifica di Linux) all'argomento \param{type} può
essere aggiunta la lettera ``\texttt{e}'' per impostare automaticamente il
-flag di \textit{close-on-exec} sul file descriptor sottostante (si ricordi
-quanto spiegato in sez.~\ref{sec:file_open_close}).
+flag di \textit{close-on-exec} sul file descriptor sottostante.
Lo \textit{stream} restituito da \func{popen} è identico a tutti gli effetti
ai \textit{file stream} visti in sez.~\ref{sec:files_std_interface}, anche se
all'interno del ciclo principale il caso in cui il server è in ascolto ma non
ci sono client che effettuano richieste. Si ricordi infatti che quando una
\textit{fifo} è aperta solo dal capo in lettura, l'esecuzione di \func{read}
-ritorna con zero byte (si ha cioè una condizione di end-of-file).
+ritorna con zero byte (si ha cioè una condizione di \textit{end-of-file}).
Nel nostro caso la prima apertura si bloccherà fintanto che un qualunque
client non apre a sua volta la \textit{fifo} nota in scrittura per effettuare
associato ad un oggetto ed accedervi. Il problema che sorge a questo punto è
come devono fare per accordarsi sull'uso di una stessa chiave. Se i processi
sono \textsl{imparentati} la soluzione è relativamente semplice, in tal caso
-infatti si può usare il valore speciale \texttt{IPC\_PRIVATE} per creare un
+infatti si può usare il valore speciale \constd{IPC\_PRIVATE} per creare un
nuovo oggetto nel processo padre, l'identificatore così ottenuto sarà
disponibile in tutti i figli, e potrà essere passato come argomento attraverso
una \func{exec}.
Se però si vogliono usare le costanti simboliche di
tab.~\ref{tab:file_mode_flags} occorrerà includere anche il file
-\headfile{sys/stat.h}; alcuni sistemi definiscono le costanti \const{MSG\_R}
-(il valore ottale \texttt{0400}) e \const{MSG\_W} (il valore ottale
+\headfile{sys/stat.h}; alcuni sistemi definiscono le costanti \constd{MSG\_R}
+(il valore ottale \texttt{0400}) e \constd{MSG\_W} (il valore ottale
\texttt{0200}) per indicare i permessi base di lettura e scrittura per il
proprietario, da utilizzare, con gli opportuni shift, pure per il gruppo e gli
altri. In Linux, visto la loro scarsa utilità, queste costanti non sono
direttamente (in lettura o scrittura) all'oggetto. In tal caso lo schema dei
controlli è simile a quello dei file, ed avviene secondo questa sequenza:
\begin{itemize*}
-\item se il processo ha i privilegi di amministratore (più precisamente la
- capacità \const{CAP\_IPC\_OWNER}) l'accesso è sempre consentito.
+\item se il processo ha i privilegi di amministratore (più precisamente
+ \const{CAP\_IPC\_OWNER}) l'accesso è sempre consentito.
\item se l'\ids{UID} effettivo del processo corrisponde o al valore del campo
\var{cuid} o a quello del campo \var{uid} ed il permesso per il proprietario
in \var{mode} è appropriato\footnote{per appropriato si intende che è
a differenza di quanto avviene per i permessi dei file, fallire in uno dei
passi elencati non comporta il fallimento dell'accesso. Un'ulteriore
differenza rispetto a quanto avviene per i file è che per gli oggetti di IPC
-il valore di \itindex{umask} \textit{umask} (si ricordi quanto esposto in
+il valore di \textit{umask} (si ricordi quanto esposto in
sez.~\ref{sec:file_perm_management}) non ha alcun significato.
relativi al \textit{SysV-IPC}) solo con una ricompilazione del kernel. A
partire dal kernel 2.4.x è possibile cambiare questi valori a sistema attivo
scrivendo sui file \sysctlrelfile{kernel}{shmmni},
-\sysctlrelfile{kernel}{msgmni} e \sysctlrelfile{kernel}{sem} di
+\sysctlrelfile{kernel}{msgmni} e \sysctlrelfiled{kernel}{sem} di
\file{/proc/sys/kernel} o con l'uso di \func{sysctl}.
\begin{figure}[!htb]
Questo in realtà è quanto avveniva fino ai kernel della serie 2.2, dalla serie
2.4 viene usato lo stesso fattore di moltiplicazione per qualunque tipo di
-oggetto, utilizzando il valore dalla costante \const{IPCMNI} (definita in
+oggetto, utilizzando il valore dalla costante \constd{IPCMNI} (definita in
\file{include/linux/ipc.h}), che indica il limite massimo complessivo per il
numero di tutti gli oggetti presenti nel \textit{SysV-IPC}, ed il cui default
è 32768. Si evita così il riutilizzo degli stessi numeri, e si fa sì che
Se invece si vuole creare una nuova coda di messaggi \param{flag} non può
essere nullo e deve essere fornito come maschera binaria, impostando il bit
-corrispondente al valore \const{IPC\_CREAT}. In questo caso i nove bit meno
+corrispondente al valore \constd{IPC\_CREAT}. In questo caso i nove bit meno
significativi di \param{flag} saranno usati come permessi per il nuovo
oggetto, secondo quanto illustrato in sez.~\ref{sec:ipc_sysv_access_control}.
-Se si imposta anche il bit corrispondente a \const{IPC\_EXCL} la funzione avrà
+Se si imposta anche il bit corrispondente a \constd{IPC\_EXCL} la funzione avrà
successo solo se l'oggetto non esiste già, fallendo con un errore di
\errcode{EEXIST} altrimenti.
& \textbf{Significato} \\
\hline
\hline
- \const{MSGMNI}& 16& \file{msgmni} & Numero massimo di code di
+ \constd{MSGMNI}& 16& \file{msgmni} & Numero massimo di code di
messaggi.\\
- \const{MSGMAX}& 8192& \file{msgmax} & Dimensione massima di un singolo
+ \constd{MSGMAX}& 8192& \file{msgmax} & Dimensione massima di un singolo
messaggio.\\
- \const{MSGMNB}&16384& \file{msgmnb} & Dimensione massima del contenuto di
+ \constd{MSGMNB}&16384& \file{msgmnb} & Dimensione massima del contenuto di
una coda.\\
\hline
\end{tabular}
definiti staticamente e corrispondenti alle prime tre costanti riportate in
tab.~\ref{tab:ipc_msg_limits}. Come accennato però con tutte le versioni più
recenti del kernel con Linux è possibile modificare questi limiti attraverso
-l'uso di \func{sysctl} o scrivendo nei file \sysctlrelfile{kernel}{msgmax},
-\sysctlrelfile{kernel}{msgmnb} e \sysctlrelfile{kernel}{msgmni} di
+l'uso di \func{sysctl} o scrivendo nei file \sysctlrelfiled{kernel}{msgmax},
+\sysctlrelfiled{kernel}{msgmnb} e \sysctlrelfiled{kernel}{msgmni} di
\file{/proc/sys/kernel/}.
\itindbeg{linked~list}
dal kernel. Lo schema illustrato in realtà è una semplificazione di quello
usato fino ai kernel della serie 2.2. A partire della serie 2.4 la gestione
delle code di messaggi è effettuata in maniera diversa (e non esiste una
-struttura \struct{msqid\_ds} nel kernel), ma abbiamo mantenuto lo schema
+struttura \kstruct{msqid\_ds} nel kernel), ma abbiamo mantenuto lo schema
precedente dato che illustra in maniera più che adeguata i principi di
funzionamento delle code di messaggi.
\begin{figure}[!htb]
\centering \includegraphics[width=13cm]{img/mqstruct}
- \caption{Schema della struttura di una coda messaggi.}
+ \caption{Schema delle strutture di una coda di messaggi
+ (\kstructd{msqid\_ds} e \kstructd{msg}).}
\label{fig:ipc_mq_schema}
\end{figure}
-A ciascuna coda è associata una struttura \struct{msqid\_ds} la cui
+A ciascuna coda è associata una struttura \kstruct{msqid\_ds} la cui
definizione è riportata in fig.~\ref{fig:ipc_msqid_ds} ed a cui si accede
includendo \headfiled{sys/msg.h};
%
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{.90\textwidth}
+ \begin{minipage}[c]{.91\textwidth}
\includestruct{listati/msqid_ds.h}
\end{minipage}
\normalsize
% primo e ultimo messaggio sono inizializzati a \val{NULL} e
% \var{msg\_cbytes}, che esprime la dimensione in byte dei messaggi presenti è
% inizializzato a zero. Questi campi sono ad uso interno dell'implementazione
-% e non devono essere utilizzati da programmi in user space).
+% e non devono essere utilizzati da programmi in \textit{user space}).
\end{itemize*}
Una volta creata una coda di messaggi le operazioni di controllo vengono
che specifica il tipo di azione da eseguire. I valori possibili
per \param{cmd} sono:
\begin{basedescript}{\desclabelwidth{1.6cm}\desclabelstyle{\nextlinelabel}}
-\item[\const{IPC\_STAT}] Legge le informazioni riguardo la coda nella
+\item[\constd{IPC\_STAT}] Legge le informazioni riguardo la coda nella
struttura \struct{msqid\_ds} indicata da \param{buf}. Occorre avere il
permesso di lettura sulla coda.
-\item[\const{IPC\_RMID}] Rimuove la coda, cancellando tutti i dati, con
+\item[\constd{IPC\_RMID}] Rimuove la coda, cancellando tutti i dati, con
effetto immediato. Tutti i processi che cercheranno di accedere alla coda
riceveranno un errore di \errcode{EIDRM}, e tutti processi in attesa su
funzioni di lettura o di scrittura sulla coda saranno svegliati ricevendo
il medesimo errore. Questo comando può essere eseguito solo da un processo
con \ids{UID} effettivo corrispondente al creatore o al proprietario della
coda, o all'amministratore.
-\item[\const{IPC\_SET}] Permette di modificare i permessi ed il proprietario
+\item[\constd{IPC\_SET}] Permette di modificare i permessi ed il proprietario
della coda, ed il limite massimo sulle dimensioni del totale dei messaggi in
essa contenuti (\var{msg\_qbytes}). I valori devono essere passati in una
struttura \struct{msqid\_ds} puntata da \param{buf}. Per modificare i
\end{basedescript}
A questi tre valori, che sono quelli previsti dallo standard, su Linux se ne
-affiancano altri tre (\const{IPC\_INFO}, \const{MSG\_STAT} e
-\const{MSG\_INFO}) introdotti ad uso del programma \cmd{ipcs} per ottenere le
+affiancano altri tre (\constd{IPC\_INFO}, \constd{MSG\_STAT} e
+\constd{MSG\_INFO}) introdotti ad uso del programma \cmd{ipcs} per ottenere le
informazioni generali relative alle risorse usate dalle code di
messaggi. Questi potranno essere modificati o rimossi in favore dell'uso di
\texttt{/proc}, per cui non devono essere usati e non li tratteremo.
cioè \var{message} è una propria struttura che si passa alla funzione,
\param{msgsz} dovrà essere uguale a \code{sizeof(message)-sizeof(long)}, (se
consideriamo il caso dell'esempio in fig.~\ref{fig:ipc_msbuf}, \param{msgsz}
-dovrà essere pari a \const{LENGTH}).
+dovrà essere pari a \var{LENGTH}).
Per capire meglio il funzionamento della funzione riprendiamo in
considerazione la struttura della coda illustrata in
-fig.~\ref{fig:ipc_mq_schema}. Alla chiamata di \func{msgsnd} il nuovo messaggio
-sarà aggiunto in fondo alla lista inserendo una nuova struttura \struct{msg},
-il puntatore \var{msg\_last} di \struct{msqid\_ds} verrà aggiornato, come pure
-il puntatore al messaggio successivo per quello che era il precedente ultimo
-messaggio; il valore di \var{mtype} verrà mantenuto in \var{msg\_type} ed il
-valore di \param{msgsz} in \var{msg\_ts}; il testo del messaggio sarà copiato
-all'indirizzo specificato da \var{msg\_spot}.
+fig.~\ref{fig:ipc_mq_schema}. Alla chiamata di \func{msgsnd} il nuovo
+messaggio sarà aggiunto in fondo alla lista inserendo una nuova struttura
+\kstruct{msg}, il puntatore \var{msg\_last} di \kstruct{msqid\_ds} verrà
+aggiornato, come pure il puntatore al messaggio successivo per quello che era
+il precedente ultimo messaggio; il valore di \var{mtype} verrà mantenuto in
+\var{msg\_type} ed il valore di \param{msgsz} in \var{msg\_ts}; il testo del
+messaggio sarà copiato all'indirizzo specificato da \var{msg\_spot}.
Il valore dell'argomento \param{flag} permette di specificare il comportamento
della funzione. Di norma, quando si specifica un valore nullo, la funzione
ritorna immediatamente a meno che si sia ecceduto il valore di
\var{msg\_qbytes}, o il limite di sistema sul numero di messaggi, nel qual
caso si blocca. Se si specifica per \param{flag} il valore
-\const{IPC\_NOWAIT} la funzione opera in modalità non-bloccante, ed in questi
+\constd{IPC\_NOWAIT} la funzione opera in modalità non-bloccante, ed in questi
casi ritorna immediatamente con un errore di \errcode{EAGAIN}.
Se non si specifica \const{IPC\_NOWAIT} la funzione resterà bloccata fintanto
formato analogo a quello di fig.~\ref{fig:ipc_msbuf}. Una volta estratto, il
messaggio sarà rimosso dalla coda. L'argomento \param{msgsz} indica la
lunghezza massima del testo del messaggio (equivalente al valore del parametro
-\const{LENGTH} nell'esempio di fig.~\ref{fig:ipc_msbuf}).
+\var{LENGTH} nell'esempio di fig.~\ref{fig:ipc_msbuf}).
Se il testo del messaggio ha lunghezza inferiore a \param{msgsz} esso viene
rimosso dalla coda; in caso contrario, se \param{msgflg} è impostato a
-\const{MSG\_NOERROR}, il messaggio viene troncato e la parte in eccesso viene
+\constd{MSG\_NOERROR}, il messaggio viene troncato e la parte in eccesso viene
perduta, altrimenti il messaggio non viene estratto e la funzione ritorna con
un errore di \errcode{E2BIG}.
Il valore di \param{msgflg} permette di controllare il comportamento della
funzione, esso può essere nullo o una maschera binaria composta da uno o più
valori. Oltre al precedente \const{MSG\_NOERROR}, sono possibili altri due
-valori: \const{MSG\_EXCEPT}, che permette, quando \param{msgtyp} è positivo,
+valori: \constd{MSG\_EXCEPT}, che permette, quando \param{msgtyp} è positivo,
di leggere il primo messaggio nella coda con tipo diverso da \param{msgtyp}, e
\const{IPC\_NOWAIT} che causa il ritorno immediato della funzione quando non
ci sono messaggi sulla coda.
funzioni \func{select} e \func{poll}. Questo rende molto scomodo usare più di
una di queste strutture alla volta; ad esempio non si può scrivere un server
che aspetti un messaggio su più di una coda senza fare ricorso ad una tecnica
-di \itindex{polling} \textit{polling} che esegua un ciclo di attesa su
-ciascuna di esse.
+di \textit{polling} che esegua un ciclo di attesa su ciascuna di esse.
Come esempio dell'uso delle code di messaggi possiamo riscrivere il nostro
server di \textit{fortunes} usando queste al posto delle \textit{fifo}. In
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{.80\textwidth}
+ \begin{minipage}[c]{.85\textwidth}
\includestruct{listati/semid_ds.h}
\end{minipage}
\normalsize
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{.80\textwidth}
+ \begin{minipage}[c]{.85\textwidth}
\includestruct{listati/sem.h}
\end{minipage}
\normalsize
\textbf{Costante} & \textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \const{SEMMNI}& 128 & Numero massimo di insiemi di semafori.\\
- \const{SEMMSL}& 250 & Numero massimo di semafori per insieme.\\
- \const{SEMMNS}&\const{SEMMNI}*\const{SEMMSL}& Numero massimo di semafori
- nel sistema.\\
- \const{SEMVMX}& 32767 & Massimo valore per un semaforo.\\
- \const{SEMOPM}& 32 & Massimo numero di operazioni per chiamata a
- \func{semop}. \\
- \const{SEMMNU}&\const{SEMMNS}& Massimo numero di strutture di ripristino.\\
- \const{SEMUME}&\const{SEMOPM}& Massimo numero di voci di ripristino.\\
- \const{SEMAEM}&\const{SEMVMX}& Valore massimo per l'aggiustamento
- all'uscita. \\
+ \constd{SEMMNI}& 128 & Numero massimo di insiemi di semafori.\\
+ \constd{SEMMSL}& 250 & Numero massimo di semafori per insieme.\\
+ \constd{SEMMNS}&\const{SEMMNI}*\const{SEMMSL}& Numero massimo di semafori
+ nel sistema.\\
+ \constd{SEMVMX}& 32767 & Massimo valore per un semaforo.\\
+ \constd{SEMOPM}& 32 & Massimo numero di operazioni per chiamata a
+ \func{semop}. \\
+ \constd{SEMMNU}&\const{SEMMNS}& Massimo numero di strutture di ripristino.\\
+ \constd{SEMUME}&\const{SEMOPM}& Massimo numero di voci di ripristino.\\
+ \constd{SEMAEM}&\const{SEMVMX}& Valore massimo per l'aggiustamento
+ all'uscita. \\
\hline
\end{tabular}
\caption{Valori delle costanti associate ai limiti degli insiemi di
\struct{semun}, la cui definizione, con i possibili valori che può assumere, è
riportata in fig.~\ref{fig:ipc_semun}.
-Nelle versioni più vecchie delle \acr{glibc} questa unione veniva definita in
+Nelle versioni più vecchie della \acr{glibc} questa unione veniva definita in
\file{sys/sem.h}, ma nelle versioni più recenti questo non avviene più in
quanto lo standard POSIX.1-2001 richiede che sia sempre definita a cura del
-chiamante. In questa seconda evenienza le \acr{glibc} definiscono però la
-macro \macro{\_SEM\_SEMUN\_UNDEFINED} che può essere usata per controllare la
+chiamante. In questa seconda evenienza la \acr{glibc} definisce però la
+macro \macrod{\_SEM\_SEMUN\_UNDEFINED} che può essere usata per controllare la
situazione.
Come già accennato sia il comportamento della funzione che il numero di
\var{sem\_ctime}. L'\ids{UID} effettivo del processo deve corrispondere o
al creatore o al proprietario dell'insieme, o all'amministratore.
L'argomento \param{semnum} viene ignorato.
-\item[\const{GETALL}] Restituisce il valore corrente di ciascun semaforo
+\item[\constd{GETALL}] Restituisce il valore corrente di ciascun semaforo
dell'insieme (corrispondente al campo \var{semval} di \struct{sem}) nel
vettore indicato da \param{arg.array}. Occorre avere il permesso di lettura.
L'argomento \param{semnum} viene ignorato.
-\item[\const{GETNCNT}] Restituisce come valore di ritorno della funzione il
+\item[\constd{GETNCNT}] Restituisce come valore di ritorno della funzione il
numero di processi in attesa che il semaforo \param{semnum} dell'insieme
\param{semid} venga incrementato (corrispondente al campo \var{semncnt} di
\struct{sem}). Va invocata con tre argomenti. Occorre avere il permesso di
lettura.
-\item[\const{GETPID}] Restituisce come valore di ritorno della funzione il
+\item[\constd{GETPID}] Restituisce come valore di ritorno della funzione il
\ids{PID} dell'ultimo processo che ha compiuto una operazione sul semaforo
\param{semnum} dell'insieme \param{semid} (corrispondente al campo
\var{sempid} di \struct{sem}). Va invocata con tre argomenti. Occorre avere
il permesso di lettura.
-\item[\const{GETVAL}] Restituisce come valore di ritorno della funzione il il
+\item[\constd{GETVAL}] Restituisce come valore di ritorno della funzione il
valore corrente del semaforo \param{semnum} dell'insieme \param{semid}
(corrispondente al campo \var{semval} di \struct{sem}). Va invocata con tre
argomenti. Occorre avere il permesso di lettura.
-\item[\const{GETZCNT}] Restituisce come valore di ritorno della funzione il
+\item[\constd{GETZCNT}] Restituisce come valore di ritorno della funzione il
numero di processi in attesa che il valore del semaforo \param{semnum}
dell'insieme \param{semid} diventi nullo (corrispondente al campo
\var{semncnt} di \struct{sem}). Va invocata con tre argomenti. Occorre
avere il permesso di lettura.
-\item[\const{SETALL}] Inizializza il valore di tutti i semafori dell'insieme,
+\item[\constd{SETALL}] Inizializza il valore di tutti i semafori dell'insieme,
aggiornando il campo \var{sem\_ctime} di \struct{semid\_ds}. I valori devono
essere passati nel vettore indicato da \param{arg.array}. Si devono avere i
privilegi di scrittura. L'argomento \param{semnum} viene ignorato.
-\item[\const{SETVAL}] Inizializza il semaforo \param{semnum} al valore passato
+\item[\constd{SETVAL}] Inizializza il semaforo \param{semnum} al valore passato
dall'argomento \param{arg.val}, aggiornando il campo \var{sem\_ctime} di
\struct{semid\_ds}. Si devono avere i privilegi di scrittura.
\end{basedescript}
Come per \func{msgctl} esistono tre ulteriori valori, \const{IPC\_INFO},
-\const{SEM\_STAT} e \const{SEM\_INFO}, specifici di Linux e fuori da ogni
+\constd{SEM\_STAT} e \constd{SEM\_INFO}, specifici di Linux e fuori da ogni
standard, creati specificamente ad uso del comando \cmd{ipcs}. Dato che anche
questi potranno essere modificati o rimossi, non devono essere utilizzati e
pertanto non li tratteremo.
Con lo standard POSIX.1-2001 è stata introdotta una variante di \func{semop}
che consente di specificare anche un tempo massimo di attesa. La nuova
-funzione di sistema, disponibile a partire dal kernel 2.4.22 e dalle
+funzione di sistema, disponibile a partire dal kernel 2.4.22 e dalla
\acr{glibc} 2.3.3, ed utilizzabile solo dopo aver definito la macro
\macro{\_GNU\_SOURCE}, è \funcd{semtimedop}, ed il suo prototipo è:
Il campo \var{sem\_flg} è un flag, mantenuto come maschera binaria, per il
quale possono essere impostati i due valori \const{IPC\_NOWAIT} e
-\const{SEM\_UNDO}. Impostando \const{IPC\_NOWAIT} si fa si che in tutti quei
+\constd{SEM\_UNDO}. Impostando \const{IPC\_NOWAIT} si fa sì che in tutti quei
casi in cui l'esecuzione di una operazione richiederebbe di porre il processo
vada nello stato di \textit{sleep}, invece di bloccarsi \func{semop} ritorni
immediatamente (abortendo così le eventuali operazioni restanti) con un errore
\begin{figure}[!htb]
\centering \includegraphics[width=12cm]{img/semtruct}
- \caption{Schema della struttura di un insieme di semafori.}
+ \caption{Schema delle varie strutture di un insieme di semafori
+ (\kstructd{semid\_ds}, \kstructd{sem}, \kstructd{sem\_queue} e
+ \kstructd{sem\_undo}).}
\label{fig:ipc_sem_schema}
\end{figure}
Alla creazione di un nuovo insieme viene allocata una nuova strutture
-\struct{semid\_ds} ed il relativo vettore di strutture \struct{sem}. Quando si
-richiede una operazione viene anzitutto verificato che tutte le operazioni
+\kstruct{semid\_ds} ed il relativo vettore di strutture \kstruct{sem}. Quando
+si richiede una operazione viene anzitutto verificato che tutte le operazioni
possono avere successo; se una di esse comporta il blocco del processo il
kernel crea una struttura \kstruct{sem\_queue} che viene aggiunta in fondo
alla coda di attesa associata a ciascun insieme di semafori, che viene
referenziata tramite i campi \var{sem\_pending} e \var{sem\_pending\_last} di
-\struct{semid\_ds}. Nella struttura viene memorizzato il riferimento alle
+\kstruct{semid\_ds}. Nella struttura viene memorizzato il riferimento alle
operazioni richieste (nel campo \var{sops}, che è un puntatore ad una
struttura \struct{sembuf}) e al processo corrente (nel campo \var{sleeper})
poi quest'ultimo viene messo stato di attesa e viene invocato lo
\textit{scheduler} per passare all'esecuzione di un altro processo.
-Se invece tutte le operazioni possono avere successo queste vengono eseguite
+Se invece tutte le operazioni possono avere successo vengono eseguite
immediatamente, dopo di che il kernel esegue una scansione della coda di
attesa (a partire da \var{sem\_pending}) per verificare se qualcuna delle
operazioni sospese in precedenza può essere eseguita, nel qual caso la
sblocco non servirebbe comunque, dato che l'operazione non sarebbe atomica.
Vedremo in sez.~\ref{sec:ipc_lock_file} come sia possibile ottenere
un'interfaccia analoga a quella appena illustrata, senza incorrere in questi
-problemi, usando il \itindex{file~locking} \textit{file locking}.
+problemi, usando il \textit{file locking}.
\subsection{Memoria condivisa}
di gestione del segmento di memoria condivisa in relazione al sistema della
memoria virtuale.
-Il primo dei due flag è \const{SHM\_HUGETLB} che consente di richiedere la
+Il primo dei due flag è \constd{SHM\_HUGETLB} che consente di richiedere la
creazione del segmento usando una \textit{huge page}, le pagine di memoria di
grandi dimensioni introdotte con il kernel 2.6 per ottimizzare le prestazioni
nei sistemi più recenti che hanno grandi quantità di memoria. L'operazione è
portabile.
Il secondo flag aggiuntivo, introdotto a partire dal kernel 2.6.15, è
-\const{SHM\_NORESERVE}, ed ha lo stesso scopo del flag \const{MAP\_NORESERVE}
+\constd{SHM\_NORESERVE}, ed ha lo stesso scopo del flag \const{MAP\_NORESERVE}
di \func{mmap} (vedi sez.~\ref{sec:file_memory_map}): non vengono riservate
delle pagine di swap ad uso del meccanismo del \textit{copy on write} per
mantenere le modifiche fatte sul segmento. Questo significa che caso di
& \textbf{Significato} \\
\hline
\hline
- \const{SHMALL}& 0x200000&\sysctlrelfile{kernel}{shmall}
- & Numero massimo di pagine che
- possono essere usate per i segmenti di
- memoria condivisa.\\
- \const{SHMMAX}&0x2000000&\sysctlrelfile{kernel}{shmmax}
- & Dimensione massima di un segmento di memoria
- condivisa.\\
- \const{SHMMNI}& 4096&\sysctlrelfile{kernel}{msgmni}
- & Numero massimo di segmenti di memoria condivisa
+ \constd{SHMALL}& 0x200000&\sysctlrelfiled{kernel}{shmall}
+ & Numero massimo di pagine che
+ possono essere usate per i segmenti di
+ memoria condivisa.\\
+ \constd{SHMMAX}&0x2000000&\sysctlrelfiled{kernel}{shmmax}
+ & Dimensione massima di un segmento di memoria
+ condivisa.\\
+ \constd{SHMMNI}& 4096&\sysctlrelfiled{kernel}{shmmni}
+ & Numero massimo di segmenti di memoria condivisa
presenti nel kernel.\\
- \const{SHMMIN}& 1& --- & Dimensione minima di un segmento di
- memoria condivisa.\\
- \const{SHMLBA}&\const{PAGE\_SIZE}&--- & Limite inferiore per le dimensioni
- minime di un segmento (deve essere
- allineato alle dimensioni di una
- pagina di memoria).\\
- \const{SHMSEG}& --- & --- & Numero massimo di segmenti di
- memoria condivisa per ciascun
- processo (l'implementazione non
- prevede l'esistenza di questo
- limite).\\
+ \constd{SHMMIN}& 1& --- & Dimensione minima di un segmento di
+ memoria condivisa.\\
+ \constd{SHMLBA}&\const{PAGE\_SIZE}&--- & Limite inferiore per le dimensioni
+ minime di un segmento (deve essere
+ allineato alle dimensioni di una
+ pagina di memoria).\\
+ \constd{SHMSEG}& --- & --- & Numero massimo di segmenti di
+ memoria condivisa per ciascun
+ processo (l'implementazione non
+ prevede l'esistenza di questo
+ limite).\\
\hline
si ha a cuore la portabilità. Questi comandi aggiuntivi sono:
\begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
-\item[\const{SHM\_LOCK}] Abilita il \textit{memory locking} sul segmento di
+\item[\constd{SHM\_LOCK}] Abilita il \textit{memory locking} sul segmento di
memoria condivisa, impedendo che la memoria usata per il segmento venga
salvata su disco dal meccanismo della memoria virtuale. Come illustrato in
sez.~\ref{sec:proc_mem_lock} fino al kernel 2.6.9 solo l'amministratore
poteva utilizzare questa capacità,\footnote{che richiedeva la
- \textit{capability} \const{CAP\_IPC\_LOCK}.} a partire dal dal kernel
- 2.6.10 anche gli utenti normali possono farlo fino al limite massimo
- determinato da \const{RLIMIT\_MEMLOCK} (vedi
- sez.~\ref{sec:sys_resource_limit}).
-\item[\const{SHM\_UNLOCK}] Disabilita il \textit{memory locking} sul segmento
+ \textit{capability} \const{CAP\_IPC\_LOCK}.} a partire dal kernel 2.6.10
+ anche gli utenti normali possono farlo fino al limite massimo determinato da
+ \const{RLIMIT\_MEMLOCK} (vedi sez.~\ref{sec:sys_resource_limit}).
+\item[\constd{SHM\_UNLOCK}] Disabilita il \textit{memory locking} sul segmento
di memoria condivisa. Fino al kernel 2.6.9 solo l'amministratore poteva
utilizzare questo comando in corrispondenza di un segmento da lui bloccato.
\end{basedescript}
A questi due, come per \func{msgctl} e \func{semctl}, si aggiungono tre
-ulteriori valori, \const{IPC\_INFO}, \const{MSG\_STAT} e \const{MSG\_INFO},
+ulteriori valori, \const{IPC\_INFO}, \constd{SHM\_STAT} e \constd{SHM\_INFO},
introdotti ad uso del programma \cmd{ipcs} per ottenere le informazioni
generali relative alle risorse usate dai segmenti di memoria condivisa. Dato
che potranno essere modificati o rimossi in favore dell'uso di \texttt{/proc},
L'argomento \param{shmaddr} specifica a quale indirizzo\footnote{lo standard
SVID prevede che l'argomento \param{shmaddr} sia di tipo \ctyp{char *}, così
- come il valore di ritorno della funzione; in Linux è stato così con le
- \acr{libc4} e le \acr{libc5}, con il passaggio alla \acr{glibc} il tipo di
+ come il valore di ritorno della funzione; in Linux è stato così con la
+ \acr{libc4} e la \acr{libc5}, con il passaggio alla \acr{glibc} il tipo di
\param{shmaddr} è divenuto un \ctyp{const void *} e quello del valore di
ritorno un \ctyp{void *} seguendo POSIX.1-2001.} deve essere associato il
segmento, se il valore specificato è \val{NULL} è il sistema a scegliere
L'argomento \param{shmflg} permette di cambiare il comportamento della
funzione; esso va specificato come maschera binaria, i bit utilizzati al
-momento sono sono tre e sono identificati dalle costanti \const{SHM\_RND},
+momento sono tre e sono identificati dalle costanti \const{SHM\_RND},
\const{SHM\_RDONLY} e \const{SHM\_REMAP} che vanno combinate con un OR
-aritmetico.
+aritmetico.
-Specificando \const{SHM\_RND} si evita che \func{shmat} ritorni un errore
+Specificando \constd{SHM\_RND} si evita che \func{shmat} ritorni un errore
quando \param{shmaddr} non è allineato ai confini di una pagina. Si può quindi
usare un valore qualunque per \param{shmaddr}, e il segmento verrà comunque
agganciato, ma al più vicino multiplo di \const{SHMLBA}; il nome della
costante sta infatti per \textit{rounded}, e serve per specificare un
indirizzo come arrotondamento.
-L'uso di \const{SHM\_RDONLY} permette di agganciare il segmento in sola
+L'uso di \constd{SHM\_RDONLY} permette di agganciare il segmento in sola
lettura (si ricordi che anche le pagine di memoria hanno dei permessi), in tal
caso un tentativo di scrivere sul segmento comporterà una violazione di
accesso con l'emissione di un segnale di \signal{SIGSEGV}. Il comportamento
\var{shm\_perm}), non è prevista la possibilità di agganciare un segmento in
sola scrittura.
-Infine \const{SHM\_REMAP} è una estensione specifica di Linux (quindi non
+Infine \constd{SHM\_REMAP} è una estensione specifica di Linux (quindi non
portabile) che indica che la mappatura del segmento deve rimpiazzare ogni
precedente mappatura esistente nell'intervallo iniziante
all'indirizzo \param{shmaddr} e di dimensione pari alla lunghezza del
segmento. In condizioni normali questo tipo di richiesta fallirebbe con un
errore di \errval{EINVAL}. Ovviamente usando \const{SHM\_REMAP}
-l'argomento \param{shmaddr} non può essere nullo.
+l'argomento \param{shmaddr} non può essere nullo.
In caso di successo la funzione \func{shmat} aggiorna anche i seguenti campi
della struttura \struct{shmid\_ds}:
sincronizzazione: anzitutto in caso di terminazione imprevista del processo,
si lascia allocata la risorsa (il \textsl{file di lock}) e questa deve essere
sempre cancellata esplicitamente. Inoltre il controllo della disponibilità
-può essere eseguito solo con una tecnica di \itindex{polling}
-\textit{polling}, ed è quindi molto inefficiente.
+può essere eseguito solo con una tecnica di \textit{polling}, ed è quindi
+molto inefficiente.
La tecnica dei file di lock ha comunque una sua utilità, e può essere usata
con successo quando l'esigenza è solo quella di segnalare l'occupazione di una
Dato che i file di lock presentano gli inconvenienti illustrati in precedenza,
la tecnica alternativa di sincronizzazione più comune è quella di fare ricorso
-al \itindex{file~locking} \textit{file locking} (trattato in
-sez.~\ref{sec:file_locking}) usando \func{fcntl} su un file creato per
-l'occasione per ottenere un write lock. In questo modo potremo usare il lock
-come un \textit{mutex}: per bloccare la risorsa basterà acquisire il lock, per
-sbloccarla basterà rilasciare il lock. Una richiesta fatta con un write lock
-metterà automaticamente il processo in stato di attesa, senza necessità di
-ricorrere al \itindex{polling} \textit{polling} per determinare la
-disponibilità della risorsa, e al rilascio della stessa da parte del processo
-che la occupava si otterrà il nuovo lock atomicamente.
+al \textit{file locking} (trattato in sez.~\ref{sec:file_locking}) usando
+\func{fcntl} su un file creato per l'occasione per ottenere un write lock. In
+questo modo potremo usare il lock come un \textit{mutex}: per bloccare la
+risorsa basterà acquisire il lock, per sbloccarla basterà rilasciare il
+lock. Una richiesta fatta con un write lock metterà automaticamente il
+processo in stato di attesa, senza necessità di ricorrere al \textit{polling}
+per determinare la disponibilità della risorsa, e al rilascio della stessa da
+parte del processo che la occupava si otterrà il nuovo lock atomicamente.
Questo approccio presenta il notevole vantaggio che alla terminazione di un
processo tutti i lock acquisiti vengono rilasciati automaticamente (alla
\includecodesample{listati/MutexLocking.c}
\end{minipage}
\normalsize
- \caption{Il codice delle funzioni che permettono per la gestione dei
- \textit{mutex} con il \itindex{file~locking} \textit{file locking}.}
+ \caption{Il codice delle funzioni che permettono per la gestione dei
+ \textit{mutex} con il \textit{file locking}.}
\label{fig:ipc_flock_mutex}
\end{figure}
Il codice delle varie funzioni usate per implementare un mutex utilizzando il
-\textit{file locking} \itindex{file~locking} è riportato in
-fig.~\ref{fig:ipc_flock_mutex}; si è mantenuta volutamente una struttura
-analoga alle precedenti funzioni che usano i semafori, anche se le due
-interfacce non possono essere completamente equivalenti, specie per quanto
-riguarda la rimozione del mutex.
+\textit{file locking} è riportato in fig.~\ref{fig:ipc_flock_mutex}; si è
+mantenuta volutamente una struttura analoga alle precedenti funzioni che 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
creare il mutex; la funzione è estremamente semplice, e si limita
La seconda funzione (\texttt{\small 6-10}) è \func{FindMutex}, che, come la
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 \itindex{file~locking} \textit{file locking},
-solo che in questo caso le opzioni di \func{open} sono tali che il file in
-questione deve esistere di già.
+aprire il file da usare per il \textit{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-22}) è \func{LockMutex} e serve per
acquisire il mutex. La funzione definisce (\texttt{\small 14}) e inizializza
rilasciare il mutex. La funzione è analoga alla precedente, solo che in questo
caso si inizializza (\texttt{\small 28-31}) la struttura \var{lock} per il
rilascio del lock, che viene effettuato (\texttt{\small 33}) con la opportuna
-chiamata a \func{fcntl}. Avendo usato il \itindex{file~locking} \textit{file
- locking} in semantica POSIX (si riveda quanto detto
-sez.~\ref{sec:file_posix_lock}) solo il processo che ha precedentemente
-eseguito il lock può sbloccare il mutex.
+chiamata a \func{fcntl}. Avendo usato il \textit{file locking} in semantica
+POSIX (si riveda quanto detto sez.~\ref{sec:file_posix_lock}) solo il processo
+che ha precedentemente eseguito il lock può sbloccare il mutex.
La quinta funzione (\texttt{\small 36-39}) è \func{RemoveMutex} e serve a
cancellare il mutex. Anche questa funzione è stata definita per mantenere una
\subsection{Il \textit{memory mapping} anonimo}
\label{sec:ipc_mmap_anonymous}
-\itindbeg{memory~mapping} Abbiamo già visto che quando i processi sono
-\textsl{correlati}, se cioè hanno almeno un progenitore comune, l'uso delle
-\textit{pipe} può costituire una valida alternativa alle code di messaggi;
-nella stessa situazione si può evitare l'uso di una memoria condivisa facendo
-ricorso al cosiddetto \textit{memory mapping} anonimo.
+\itindbeg{memory~mapping}
+
+Abbiamo già visto che quando i processi sono \textsl{correlati}, se cioè hanno
+almeno un progenitore comune, l'uso delle \textit{pipe} può costituire una
+valida alternativa alle code di messaggi; nella stessa situazione si può
+evitare l'uso di una memoria condivisa facendo ricorso al cosiddetto
+\textit{memory mapping} anonimo.
In sez.~\ref{sec:file_memory_map} abbiamo visto come sia possibile mappare il
contenuto di un file nella memoria di un processo, e che, quando viene usato
nel \textit{memory mapping} anonimo.} Vedremo come utilizzare questa tecnica
più avanti, quando realizzeremo una nuova versione del monitor visto in
sez.~\ref{sec:ipc_sysv_shm} che possa restituisca i risultati via rete.
+
\itindend{memory~mapping}
% TODO: fare esempio di mmap anonima
% TODO: con il kernel 3.17 è stata introdotta una fuunzionalità di
% sigillatura dei file mappati in memoria e la system call memfd
% (capire se va messo qui o altrove) vedi: http://lwn.net/Articles/593918/
+% col 5.1 aggiunta a memfd F_SEAL_FUTURE_WRITE, vedi
+% https://git.kernel.org/linus/ab3948f58ff8 e https://lwn.net/Articles/782511/
\section{L'intercomunicazione fra processi di POSIX}
Oggi Linux supporta tutti gli oggetti definito nello standard POSIX per l'IPC,
ma a lungo non è stato così; la memoria condivisa è presente a partire dal
kernel 2.4.x, i semafori sono forniti dalla \acr{glibc} nella sezione che
-implementa i \itindex{thread} \textit{thread} POSIX di nuova generazione che
-richiedono il kernel 2.6, le code di messaggi sono supportate a partire dal
-kernel 2.6.6.
+implementa i \textit{thread} POSIX di nuova generazione che richiedono il
+kernel 2.6, le code di messaggi sono supportate a partire dal kernel 2.6.6.
La caratteristica fondamentale dell'interfaccia POSIX è l'abbandono dell'uso
degli identificatori e delle chiavi visti nel \textit{SysV-IPC}, per passare ai
La funzione apre la coda di messaggi identificata dall'argomento \param{name}
restituendo il descrittore ad essa associato, del tutto analogo ad un file
descriptor, con l'unica differenza che lo standard prevede un apposito tipo
-\type{mqd\_t}. Nel caso di Linux si tratta in effetti proprio di un normale
+\typed{mqd\_t}. Nel caso di Linux si tratta in effetti proprio di un normale
file descriptor; pertanto, anche se questo comportamento non è portabile, lo
si può tenere sotto osservazione con le funzioni dell'I/O multiplexing (vedi
sez.~\ref{sec:file_multiplexing}) come possibile alternativa all'uso
di \errcode{EINVAL}. Se \param{attr} è un puntatore nullo gli attributi della
coda saranno impostati ai valori predefiniti.
-I suddetti limiti di sistema sono impostati attraverso altrettanti file in
-\texttt{/proc/sys/fs/mqueue}, in particolare i file che controllano i valori
-dei limiti sono:
+I suddetti limiti di sistema sono impostati attraverso una serie di file
+presenti sotto \texttt{/proc/sys/fs/mqueue}, in particolare i file che
+controllano i valori dei limiti sono:
\begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
-\item[\sysctlfile{fs/mqueue/msg\_max}] Indica il valore massimo del numero di
+\item[\sysctlfiled{fs/mqueue/msg\_max}] Indica il valore massimo del numero di
messaggi in una coda e agisce come limite superiore per il valore di
\var{attr->mq\_maxmsg} in \func{mq\_open}. Il suo valore di default è 10. Il
- valore massimo è \const{HARD\_MAX} che vale \code{(131072/sizeof(void *))},
+ valore massimo è \constd{HARD\_MAX} che vale \code{(131072/sizeof(void *))},
ed il valore minimo 1 (ma era 10 per i kernel precedenti il 2.6.28). Questo
limite viene ignorato per i processi con privilegi amministrativi (più
precisamente con la \textit{capability} \const{CAP\_SYS\_RESOURCE}) ma
\const{HARD\_MAX} resta comunque non superabile.
-\item[\sysctlfile{fs/mqueue/msgsize\_max}] Indica il valore massimo della
+\item[\sysctlfiled{fs/mqueue/msgsize\_max}] Indica il valore massimo della
dimensione in byte di un messaggio sulla coda ed agisce come limite
superiore per il valore di \var{attr->mq\_msgsize} in \func{mq\_open}. Il
suo valore di default è 8192. Il valore massimo è 1048576 ed il valore
processi con privilegi amministrativi (con la \textit{capability}
\const{CAP\_SYS\_RESOURCE}).
-\item[\sysctlfile{fs/mqueue/queues\_max}] Indica il numero massimo di code di
+\item[\sysctlfiled{fs/mqueue/queues\_max}] Indica il numero massimo di code di
messaggi creabili in totale sul sistema, il valore di default è 256 ma si
può usare un valore qualunque fra $0$ e \const{INT\_MAX}. Il limite non
viene applicato ai processi con privilegi amministrativi (cioè con la
La funzione è analoga a \func{close},\footnote{su Linux, dove le code sono
implementate come file su un filesystem dedicato, è esattamente la stessa
funzione, per cui non esiste una \textit{system call} autonoma e la funzione
- viene rimappata su \func{close} dalle \acr{glibc}.} dopo la sua esecuzione
+ viene rimappata su \func{close} dalla \acr{glibc}.} dopo la sua esecuzione
il processo non sarà più in grado di usare il descrittore della coda, ma
quest'ultima continuerà ad esistere nel sistema e potrà essere acceduta con
un'altra chiamata a \func{mq\_open}. All'uscita di un processo tutte le code
\fhead{time.h}
\fdecl{int mq\_timedsend(mqd\_t mqdes, const char *msg\_ptr, size\_t
msg\_len, \\
-\phantom{int mq\_timedsend(}unsigned int msg\_prio, const struct timespec *abs\_timeout)}
+\phantom{int mq\_timedsend(}unsigned int msg\_prio, const struct timespec
+*abs\_timeout)}
\fdesc{Esegue l'inserimento di un messaggio su una coda entro un tempo
specificato}
}
Se quest'ultima eccede la dimensione massima specificata da \var{mq\_msgsize}
le funzioni ritornano immediatamente con un errore di \errcode{EMSGSIZE}.
-L'argomento \param{msg\_prio} indica la priorità dell'argomento, che, essendo
-definito come \ctyp{unsigned int}, è sempre un intero positivo. I messaggi di
+L'argomento \param{msg\_prio} indica la priorità dell'argomento che essendo
+definito come \ctyp{unsigned int} è sempre un intero positivo. I messaggi di
priorità maggiore vengono inseriti davanti a quelli di priorità inferiore, e
quindi saranno riletti per primi. A parità del valore della priorità il
messaggio sarà inserito in coda a tutti quelli che hanno la stessa priorità
che quindi saranno letti con la politica di una \textit{fifo}. Il valore della
-priorità non può eccedere il limite di sistema \const{MQ\_PRIO\_MAX}, che al
+priorità non può eccedere il limite di sistema \constd{MQ\_PRIO\_MAX}, che al
momento è pari a 32768.
Qualora la coda sia piena, entrambe le funzioni si bloccano, a meno che non
Il filesystem riconosce, oltre quelle mostrate, le opzioni \texttt{uid} e
\texttt{gid} che identificano rispettivamente utente e gruppo cui assegnarne
la titolarità, e \texttt{nr\_blocks} che permette di specificarne la
-dimensione in blocchi, cioè in multipli di \const{PAGECACHE\_SIZE} che in
+dimensione in blocchi, cioè in multipli di \constd{PAGECACHE\_SIZE} che in
questo caso è l'unità di allocazione elementare.
La funzione che permette di aprire un segmento di memoria condivisa POSIX, ed
\label{sec:ipc_posix_sem}
Fino alla serie 2.4.x del kernel esisteva solo una implementazione parziale
-dei semafori POSIX che li realizzava solo a livello di \itindex{thread}
-\textit{thread} e non di processi,\footnote{questo significava che i semafori
- erano visibili solo all'interno dei \itindex{thread} \textit{thread} creati
- da un singolo processo, e non potevano essere usati come meccanismo di
- sincronizzazione fra processi diversi.} fornita attraverso la sezione delle
-estensioni \textit{real-time} della \acr{glibc} (quelle che si accedono
-collegandosi alla libreria \texttt{librt}). Esisteva inoltre una libreria che
-realizzava (parzialmente) l'interfaccia POSIX usando le funzioni dei semafori
-di \textit{SysV-IPC} (mantenendo così tutti i problemi sottolineati in
+dei semafori POSIX che li realizzava solo a livello di \textit{thread} e non
+di processi,\footnote{questo significava che i semafori erano visibili solo
+ all'interno dei \textit{thread} creati da un singolo processo, e non
+ potevano essere usati come meccanismo di sincronizzazione fra processi
+ diversi.} fornita attraverso la sezione delle estensioni \textit{real-time}
+della \acr{glibc} (quelle che si accedono collegandosi alla libreria
+\texttt{librt}). Esisteva inoltre una libreria che realizzava (parzialmente)
+l'interfaccia POSIX usando le funzioni dei semafori di \textit{SysV-IPC}
+(mantenendo così tutti i problemi sottolineati in
sez.~\ref{sec:ipc_sysv_sem}).
A partire dal kernel 2.5.7 è stato introdotto un meccanismo di
sigla sta per \textit{fast user mode mutex}) con il quale è stato possibile
implementare una versione nativa dei semafori POSIX. Grazie a questo con i
kernel della serie 2.6 e le nuove versioni della \acr{glibc} che usano questa
-nuova infrastruttura per quella che viene che viene chiamata \textit{New Posix
- Thread Library}, sono state implementate anche tutte le funzioni
-dell'interfaccia dei semafori POSIX.
+nuova infrastruttura per quella che viene chiamata \textit{New Posix Thread
+ Library}, sono state implementate anche tutte le funzioni dell'interfaccia
+dei semafori POSIX.
Anche in questo caso è necessario appoggiarsi alla libreria per le estensioni
\textit{real-time} \texttt{librt}, questo significa che se si vuole utilizzare
\fdesc{Crea un semaforo o ne apre uno esistente.}
}
{La funzione ritorna l'indirizzo del semaforo in caso di successo e
- \const{SEM\_FAILED} per un errore, nel qual caso \var{errno} assumerà uno
+ \constd{SEM\_FAILED} per un errore, nel qual caso \var{errno} assumerà uno
dei valori:
\begin{errlist}
\item[\errcode{EACCES}] il semaforo esiste ma non si hanno permessi
\item[\errcode{EEXIST}] si sono specificati \const{O\_CREAT} e
\const{O\_EXCL} ma il semaforo esiste.
\item[\errcode{EINVAL}] il valore di \param{value} eccede
- \const{SEM\_VALUE\_MAX} o il nome è solo ``\texttt{/}''.
+ \constd{SEM\_VALUE\_MAX} o il nome è solo ``\texttt{/}''.
\item[\errcode{ENAMETOOLONG}] si è utilizzato un nome troppo lungo.
\item[\errcode{ENOENT}] non si è usato \const{O\_CREAT} ed il nome
specificato non esiste.
semafori usano la semantica standard dei file per quanto riguarda i controlli
di accesso, questo significa che un nuovo semaforo viene sempre creato con
l'\ids{UID} ed il \ids{GID} effettivo del processo chiamante, e che i permessi
-indicati con \param{mode} vengono filtrati dal valore della \itindex{umask}
-\textit{umask} del processo. Inoltre per poter aprire un semaforo è
-necessario avere su di esso sia il permesso di lettura che quello di
-scrittura.
+indicati con \param{mode} vengono filtrati dal valore della \textit{umask} del
+processo. Inoltre per poter aprire un semaforo è necessario avere su di esso
+sia il permesso di lettura che quello di scrittura.
La funzione restituisce in caso di successo un puntatore all'indirizzo del
semaforo con un valore di tipo \ctyp{sem\_t *}, è questo valore che dovrà
decrementarlo con successo e proseguire.
Si tenga presente che la funzione può sempre essere interrotta da un segnale,
-nel qual caso si avrà un errore di \const{EINTR}; inoltre questo avverrà
+nel qual caso si avrà un errore di \errval{EINTR}; inoltre questo avverrà
comunque, anche qualora si fosse richiesta la gestione con la semantica BSD,
installando il gestore del suddetto segnale con l'opzione \const{SA\_RESTART}
(vedi sez.~\ref{sec:sig_sigaction}) per riavviare le \textit{system call}
La funzione incrementa di uno il valore corrente del semaforo indicato
dall'argomento \param{sem}, se questo era nullo la relativa risorsa risulterà
-sbloccata, cosicché un altro processo (o \itindex{thread} \textit{thread})
-eventualmente bloccato in una \func{sem\_wait} sul semaforo possa essere
-svegliato e rimesso in esecuzione. Si tenga presente che la funzione è sicura
-per l'uso all'interno di un gestore di segnali (si ricordi quanto detto in
+sbloccata, cosicché un altro processo (o \textit{thread}) eventualmente
+bloccato in una \func{sem\_wait} sul semaforo possa essere svegliato e rimesso
+in esecuzione. Si tenga presente che la funzione è sicura per l'uso
+all'interno di un gestore di segnali (si ricordi quanto detto in
sez.~\ref{sec:sig_signal_handler}).
Se invece di operare su un semaforo se ne volesse semplicemente leggere il
La funzione inizializza un semaforo all'indirizzo puntato dall'argomento
\param{sem}, e come per \func{sem\_open} consente di impostare un valore
iniziale con \param{value}. L'argomento \param{pshared} serve ad indicare se
-il semaforo deve essere utilizzato dai \itindex{thread} \textit{thread} di uno
-stesso processo (con un valore nullo) o condiviso fra processi diversi (con un
-valore non nullo).
+il semaforo deve essere utilizzato dai \textit{thread} di uno stesso processo
+(con un valore nullo) o condiviso fra processi diversi (con un valore non
+nullo).
Qualora il semaforo debba essere condiviso dai \textit{thread} di uno stesso
processo (nel qual caso si parla di \textit{thread-shared semaphore}),
essere stato inizializzato con \func{sem\_init}; non deve quindi essere
applicata a semafori creati con \func{sem\_open}. Inoltre si deve essere
sicuri che il semaforo sia effettivamente inutilizzato, la distruzione di un
-semaforo su cui sono presenti processi (o \itindex{thread} \textit{thread}) in
-attesa (cioè bloccati in una \func{sem\_wait}) provoca un comportamento
-indefinito.
+semaforo su cui sono presenti processi (o \textit{thread}) in attesa (cioè
+bloccati in una \func{sem\_wait}) provoca un comportamento indefinito.
Si tenga presente infine che utilizzare un semaforo che è stato distrutto con
\func{sem\_destroy} di nuovo può dare esito a comportamenti indefiniti. Nel
eseguite da \file{message\_getter}). Terminato il tempo di attesa si rilascerà
(\texttt{\small 29-32}) il semaforo per poi uscire.
-Per verificare il funzionamento dei programmi occorrerà lanciare per primo
-\file{message\_getter}\footnote{lanciare per primo \file{message\_setter} darà
- luogo ad un errore, non essendo stati creati il semaforo ed il segmento di
- memoria condivisa.} che inizierà a stampare una volta al secondo il
-contenuto del messaggio ed i suoi dati, con qualcosa del tipo:
+Per verificare il funzionamento dei programmi occorrerà lanciare prima
+\file{message\_getter} (lanciare per primo \file{message\_setter} darebbe
+luogo ad un errore, non essendo stati creati il semaforo ed il segmento di
+memoria condivisa) che inizierà a stampare una volta al secondo il contenuto
+del messaggio ed i suoi dati, con qualcosa del tipo:
\begin{Console}
piccardi@hain:~/gapil/sources$ \textbf{./message_getter messaggio}
sem=1, Fri Dec 31 14:12:41 2010
\end{Console}
%$
dove il programma si fermerà per 3 secondi prima di rilasciare il semaforo e
-terminare.
-
-L'effetto di questo programma si potrà però apprezzare meglio nell'uscita di
-\file{message\_getter}, che verrà interrotta per questo stesso tempo, prima di
+terminare. L'effetto di tutto ciò si potrà vedere nell'\textit{output} di
+\file{message\_getter}, che verrà interrotto per questo stesso tempo, prima di
ricominciare con il nuovo testo:
\begin{Console}
...
testo alla terminazione di quest'ultimo.
+
+% TODO: trattare i futex (segnalati altrove come sezione xxx_futex), non mi è
+% chiaro ancora dove mettere questa parte. Per gli argomenti vedi comunque:
+% man futex, https://lwn.net/Articles/360699/,
+% https://www.man7.org/linux/man-pages/man7/futex.7.html ed inoltre
+% https://lwn.net/Articles/172149/, https://lwn.net/Articles/387246/,
+% https://lwn.net/Articles/178253/, https://lwn.net/Articles/823513/,
+% https://lwn.net/Articles/655044/
+
+% TODO: trattare futex_waitv, introdotta con il 5.16, vedi:
+% https://lwn.net/Articles/866112/
+
+
% LocalWords: like fifo System POSIX RPC Calls Common Object Request Brocker
% LocalWords: Architecture descriptor kernel unistd int filedes errno EMFILE
% LocalWords: ENFILE EFAULT BUF sez fig fork Stevens siblings EOF read SIGPIPE
projects / gapil.git / blobdiff