.\" -*- coding: UTF-8 -*- .\" Copyright (c) 1993 by Thomas Koenig .\" and Copyright (c) 2004 by Michael Kerrisk .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\" Modified Sat Jul 24 13:30:06 1993 by Rik Faith .\" Modified Sun Aug 21 17:42:42 1994 by Rik Faith .\" (Thanks to Koen Holtman ) .\" Modified Wed May 17 15:54:12 1995 by Rik Faith .\" To remove *'s from status in macros (Thanks to Michael Shields). .\" Modified as suggested by Nick Duffek , aeb, 960426 .\" Modified Mon Jun 23 14:09:52 1997 by aeb - add EINTR. .\" Modified Thu Nov 26 02:12:45 1998 by aeb - add SIGCHLD stuff. .\" Modified Mon Jul 24 21:37:38 2000 by David A. Wheeler .\" - noted thread issues. .\" Modified 26 Jun 01 by Michael Kerrisk .\" Added __WCLONE, __WALL, and __WNOTHREAD descriptions .\" Modified 2001-09-25, aeb .\" Modified 26 Jun 01 by Michael Kerrisk, .\" Updated notes on setting disposition of SIGCHLD to SIG_IGN .\" 2004-11-11, mtk .\" Added waitid(2); added WCONTINUED and WIFCONTINUED() .\" Added text on SA_NOCLDSTOP .\" Updated discussion of SA_NOCLDWAIT to reflect 2.6 behavior .\" Much other text rewritten .\" 2005-05-10, mtk, __W* flags can't be used with waitid() .\" 2008-07-04, mtk, removed erroneous text about SA_NOCLDSTOP .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH wait 2 "5 febbraio 2023" "Linux man\-pages 6.03" .SH NOME wait, waitpid, waitid \- aspetta che il processo cambi stato .SH LIBRARY Standard C library (\fIlibc\fP, \fI\-lc\fP) .SH SINTASSI .nf \fB#include \fP .PP \fBpid_t wait(int *_Nullable \fP\fIwstatus\fP\fB);\fP \fBpid_t waitpid(pid_t \fP\fIpid\fP\fB, int *_Nullable \fP\fIwstatus\fP\fB, int \fP\fIoptions\fP\fB);\fP .PP \fBint waitid(idtype_t \fP\fIidtype\fP\fB, id_t \fP\fIid\fP\fB, siginfo_t *\fP\fIinfop\fP\fB, int \fP\fIopzioni\fP\fB);\fP /* Questa è l'interfaccia di glibc e POSIX ; si veda NOTES for informazioni sulla chiamata di sistema diretta. */ .fi .PP .RS -4 Macro per test di funzionalità per glibc (vedere \fBfeature_test_macros\fP(7)): .RE .PP \fBwaitid\fP(): .nf .\" (_XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED) Since glibc 2.26: _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L glibc 2.25 and earlier: _XOPEN_SOURCE || /* Since glibc 2.12: */ _POSIX_C_SOURCE >= 200809L || /* glibc <= 2.19: */ _BSD_SOURCE .fi .SH DESCRIZIONE Tutte queste chiamate di sistema si usano per attendere cambiamenti di stato in un processo figlio del processo chiamante, e ottenere informazioni sul processo figlio il cui stato è cambiato. Un cambiamento di stato avviene quando: il processo figlio è terminato; il processo figlio è stato arrestato da un segnale; il processo figlio è stato ripristinato da un segnale. In caso di un processo figlio terminato, un'attesa permette al sistema di rilasciare le risorse associate al processo figlio; se non viene eseguita un'attesa, allora il processo figlio terminato rimane in uno stato "zombie" (vedere le NOTE sotto). .PP Se un processo figlio ha già cambiato stato, allora le chiamate tornano immediatamente. Altrimenti esse si bloccano fino a quando un processo figlio cambia stato o un gestore di segnale interrompe la chiamata (supponendo che le chiamate di sistema non siano automaticamente riavviate usando il flag \fBSA_RESTART\fP di \fBsigaction\fP(2)). Nel resto di questa pagina un processo figlio il cui stato è cambiato, e che nessuna di queste chiamate di sistema ha aspettato, è definito \fIaspettabile\fP. .SS "wait() e waitpid()" La chiamata di sistema \fBwait\fP() sospende l'esecuzione del thread chiamante fino a quando uno dei suoi figli termina. La chiamata \fIwait(&wstatus)\fP è equivalente a: .PP .in +4n .EX waitpid(\-1, &wstatus, 0); .EE .in .PP La chiamata di sistema \fBwaitpid\fP() sospende l'esecuzione del thread chiamante fino a quando un processo figlio specificato dall'argomento \fIpid\fP ha cambiato stato. Il comportamento predefinito di \fBwaitpid\fP() è attendere solo i figli terminati, ma questo comportamento è modificabile attraverso l'argomento \fIopzioni\fP come descritto di seguito. .PP Il valore di \fIpid\fP può essere: .TP < \fB\-1\fP che significa attesa di qualunque processo figlio il cui gruppo ID del processo sia uguale al valore assoluto di \fIpid\fP. .TP \fB\-1\fP che significa aspettare qualunque processo figlio. .TP \fB0\fP che significa aspettare qualunque processo figlio il cui gruppo ID del processo sia uguale a quello del processo chiamante al momento della chiamata a \fBwaitpid\fP(). .TP > \fB0\fP che significa aspettare il processo figlio il cui ID di processo sia uguale al valore di \fIpid\fP. .PP Il valore di \fIopzioni\fP è un OR di zero o più delle seguenti costanti: .TP \fBWNOHANG\fP torna immediatamente se nessun processo figlio è uscito. .TP \fBWUNTRACED\fP torna anche se un processo figlio si è arrestato (ma non tracciato attraverso \fBptrace\fP(2)). Lo stato del processo figlio non \fItracciato\fP che è stato arrestato è fornito anche se l'opzione non è specificata. .TP \fBWCONTINUED\fP (a partire da Linux 2.6.10) torna anche se un processo figlio arrestato è stato riesumato inviando \fBSIGCONT\fP. .PP (Per le opzioni solo Linux vedere oltre). .PP Se \fIwstatus\fP non è NULL, \fBwait\fP() e \fBwaitpid\fP() memorizzano l'informazione di stato in \fIint\fP a cui punta. Questo intero può essere verificato con le seguenti macro (che prendono lo stesso intero come argomento, non come un puntatore ad esso, come fanno \fBwait\fP() e \fBwaitpid\fP()!): .TP \fBWIFEXITED(\fP\fIwstatus\fP\fB)\fP restituisce true se il processo figlio è terminato normalmente, ovvero, chiamando \fBexit\fP(3) o \fB_exit\fP(2), o tornando da main(). .TP \fBWEXITSTATUS(\fP\fIwstatus\fP\fB)\fP ritorna lo stato di uscita del processo figlio. Esso consiste negli 8 bit meno significativi dell'argomento \fIstatus\fP che il processo figlio ha specificato in una chiamata a \fBexit\fP(3) o \fB_exit\fP(2) o come argomento per una dichiarazione di ritorno in main(). Questa macro deve essere impiegata solo se \fBWIFEXITED\fP restituisce true. .TP \fBWIFSIGNALED(\fP\fIwstatus\fP\fB)\fP restituisce true se il processo figlio è stato terminato da un segnale. .TP \fBWTERMSIG(\fP\fIwstatus\fP\fB)\fP restituisce il numero del segnale che ha causato l'arresto del processo figlio. Questa macro deve essere impiegata solo se \fBWIFSIGNALED\fP ha restituito true. .TP \fBWCOREDUMP(\fP\fIwstatus\fP\fB)\fP restituisce true se il processo figlio ha prodotto un core dump (si veda \fBcore\fP(5)). Questa macro deve essere impiegata solo se \fBWIFSIGNALED\fP ha restituito true. .IP Questa macro non è specificata in POSIX.1\-2001 e non è disponibile in alcune implementazioni Unix (per esempio AIX, SunOS). Usarla solo racchiusa all'interno di \fI#ifdef WCOREDUMP ... #endif\fP. .TP \fBWIFSTOPPED(\fP\fIwstatus\fP\fB)\fP restituisce true se il processo figlio è stato arrestato inviando un segnale; questo è possibile solo se la chiamata è stata effettuata usando \fBWUNTRACED\fP o quando il processo figlio è stato tracciato (vedere \fBptrace\fP(2)). .TP \fBWSTOPSIG(\fP\fIwstatus\fP\fB)\fP restituisce il numero del segnale che ha causato l'arresto del processo figlio. Questa macro deve essere impiegata solo se \fBWIFSTOPPED\fP ha restituito true. .TP \fBWIFCONTINUED(\fP\fIwstatus\fP\fB)\fP (A partire da Linux 2.6.10) restituisce true se il processo figlio è stato riesumato inviando \fBSIGCONT\fP. .SS waitid() La chiamata di sistema \fBwaitid\fP() (disponibile a partire da Linux 2.6.9) fornisce un controllo più preciso su quale cambiamento di stato del processo figlio aspettare. .PP Gli argomenti \fIidtype\fP e \fIid\fP selezionano il processo figlio(i) da aspettare, come segue: .TP \fIidtype\fP == \fBP_PID\fP Aspetta il processo figlio il cui ID di processo corrisponde a \fIid\fP. .TP \fIidtype\fP == \fBP_PIDFD\fP (a partire da Linux 5.4) .\" commit 3695eae5fee0605f316fbaad0b9e3de791d7dfaf Aspetta il processo figlio a cui fa riferimento il descrittore di file di PID specificato in \fIid\fP. (Si veda \fBpidfd_open\fP(2) per ulteriori informazioni sui descrittori di file di PID.) .TP \fIidtype\fP == \fBP_PGID\fP .\" commit 821cc7b0b205c0df64cce59aacc330af251fa8f7 Aspetta qualunque processo figlio il cui ID di gruppo del processo corrisponda a \fIid\fP. Da Linux 5.4, se \fIid\fP è zero, aspetta qualsiasi processo figlio che è nello stesso gruppo di processi del gruppo di processi del chiamante al momento della chiamata. .TP \fIidtype\fP == \fBP_ALL\fP Aspetta qualunque processo figlio; \fIid\fP è ignorato. .PP Il cambiamento di stato del processo figlio da aspettare è specificato eseguendo un OR su uno o più dei seguenti flag in \fIopzioni\fP: .TP \fBWEXITED\fP Aspetta il processo figlio che è terminato. .TP \fBWSTOPPED\fP Aspetta il processo figlio che è stato arrestato con l'invio di un segnale. .TP \fBWCONTINUED\fP Aspetta i figli (precedentemente arrestati) che sono stati riesumati inviando \fBSIGCONT\fP. .PP Si può inoltre eseguire un OR sui seguenti flag in \fIopzioni\fP: .TP \fBWNOHANG\fP Come per \fBwaitpid\fP(). .TP \fBWNOWAIT\fP Lascia il processo figlio in uno stato aspettabile; una successiva chiamata di attesa può essere usata per trovare di nuovo l'informazione sullo stato del processo figlio. .PP In seguito a un ritorno con successo, \fBwaitid\fP() riempie i seguenti campi della struttura \fIsiginfo_t\fP a cui punta \fIinfop\fP: .TP \fIsi_pid\fP L'ID di processo del processo figlio. .TP \fIsi_uid\fP L'ID reale dell'utente del processo figlio. (Questo campo non viene impostato nella maggior parte delle altre implementazioni.) .TP \fIsi_signo\fP Imposta sempre a \fBSIGCHLD\fP. .TP \fIsi_status\fP O lo stato di uscita del processo figlio, come dato a \fB_exit\fP(2) (o \fBexit\fP(3)), o il segnale che ha causato la terminazione, l'arresto o la continuazione del processo figlio. Il campo \fIsi_code\fP può essere usato per determinare come interpretare questo campo. .TP \fIsi_code\fP Imposta a uno tra: \fBCLD_EXITED\fP (processo figlio chiamato \fB_exit\fP(2)); \fBCLD_KILLED\fP (processo figlio terminato da un segnale); \fBCLD_DUMPED\fP (processo figlio terminato da un segnale, ed eseguito un core dump); \fBCLD_STOPPED\fP (processo figlio arrestato da un segnale); \fBCLD_TRAPPED\fP (il processo figlio tracciato è stato bloccato); o \fBCLD_CONTINUED\fP (processo figlio continuato da \fBSIGCONT\fP). .PP Se \fBWNOHANG\fP è stato specificato in \fIopzioni\fP e non c'erano figli in uno stato aspettabile, allora \fBwaitid\fP() restituisce immediatamente 0, e lo stato della struttura \fIsiginfo_t\fP a cui punta \fIinfop\fP dipende dall'implementazione. Per distinguere (in modo portabile) questo caso da quello in cui un processo figlio era in uno stato aspettabile, il campo \fIsi_pid\fP viene impostato a zero prima della chiamata e, dopo il ritorno della chiamata, verifica che in questo campo non ci sia un valore zero. .PP .\" POSIX.1-2001 leaves this possibility unspecified; most .\" implementations (including Linux) zero out the structure .\" in this case, but at least one implementation (AIX 5.1) .\" does not -- MTK Nov 04 POSIX.1\-2008 Technical Corrigendum 1 (2013) aggiunge il requisito secondo il quale, quando viene specificato \fBWNOHANG\fP nelle \fIopzioni\fP e non ci sono figli in uno stato aspettabile, \fBwaitid\fP() dovrebbe impostate a zero i campi \fIsi_pid\fP e \fIsi_signo\fP della struttura. Su Linux e altre implementazioni che aderiscono a questi requisiti, non è necessario azzerare il campo \fIsi_pid\fP prima di chiamare \fBwaitid\fP(). Comunque, non tutte le implementazioni seguono le specifiche POSIX.1 riguardo a questo punto. .SH "VALORE RESTITUITO" \fBwait\fP(): in caso di successo, restituisce l'ID del processo del processo figlio terminato; in caso di insuccesso restituisce \-1. .PP \fBwaitpid\fP(): in caso di successo, restituisce l'ID del processo del processo figlio il cui stato è cambiato; se \fBWNOHANG\fP era specificato e uno o più figli specificati da \fIpid\fP esiste, ma non ha ancora cambiato stato, allora viene restituito 0. In caso di insuccesso restituisce \-1. .PP .\" FIXME As reported by Vegard Nossum, if infop is NULL, then waitid() .\" returns the PID of the child. Either this is a bug, or it is intended .\" behavior that needs to be documented. See my Jan 2009 LKML mail .\" "waitid() return value strangeness when infop is NULL". \fBwaitid\fP(): restituisce 0 in caso di successo o se \fBWNOHANG\fP era specificato e nessun processo figlio(i) specificato da \fIid\fP ha ancora cambiato stato; in caso di insuccesso restituisce \-1. .PP Ciascuna di queste chiamate imposta \fIerrno\fP ad un valore per indicare l'errore. .SH ERRORI .TP \fBEAGAIN\fP The PID file descriptor specified in \fIid\fP is nonblocking and the process that it refers to has not terminated. .TP \fBECHILD\fP (per \fBwait\fP()) Il processo chiamante non ha nessun processo figlio inaspettato. .TP \fBECHILD\fP (per \fBwaitpid\fP() o \fBwaitid\fP()) Il processo specificato da \fIpid\fP (\fBwaitpid\fP()) o \fIidtype\fP e \fIid\fP (\fBwaitid\fP()) non esiste o non è un processo figlio del processo chiamante (ciò può accadere per il processo figlio di un processo se l'azione per \fBSIGCHLD\fP è impostata a \fBSIG_IGN\fP. Vedere anche la sezione \fINote Linux\fP sui thread). .TP \fBEINTR\fP \fBWNOHANG\fP non era impostata ed è stato intercettato un segnale sbloccato o un \fBSIGCHLD\fP; vedere \fBsignal\fP(7). .TP \fBEINVAL\fP Gli argomenti delle \fIopzioni\fP non erano validi. .TP \fBESRCH\fP (per \fBwait\fP() o \fBwaitpid\fP()) \fIpid\fP è uguale a \fBINT_MIN\fP. .SH STANDARDS SVr4, 4.3BSD, POSIX.1\-2001. .SH NOTE Un processo figlio che termina, ma in modo inaspettato, diviene uno "zombie". Il kernel mantiene un insieme minimo di informazioni sui processi zombie (PID, stato di terminazione, informazioni sull'uso delle risorse) allo scopo di permettere al padre di eseguire in seguito un wait per ottenere informazioni sul processo figlio. Se uno zombie non viene rimosso dal sistema attraverso un wait, esso consumerà uno slot nella tabella dei processi del kernel, e se questa tabella si riempie, non sarà possibile creare ulteriori processi. Se un processo padre termina, allora i suoi figli "zombie" (se ce ne sono) sono adottati da \fBinit\fP(1) (o dal processo "subreaper" più vicino come definito attraverso l'uso dell'operazione \fBprctl\fP(2) \fBPR_SET_CHILD_SUBREAPER\fP); \fBinit\fP(1) esegue automaticamente un wait per rimuovere gli zombie. .PP POSIX.1\-2001 specifica che se la disposizione di \fBSIGCHLD\fP è impostata a \fBSIG_IGN\fP o il flag \fBSA_NOCLDWAIT\fP è impostato per \fBSIGCHLD\fP (vedere \fBsigaction\fP(2)), i figli terminati non diventano zombie e una chiamata a \fBwait\fP() o \fBwaitpid\fP() verrà bloccata fino a quando tutti i figli sono terminati, e in seguito fallisce con \fIerrno\fP impostato a \fBECHILD\fP. (Lo standard POSIX originale lasciava il comportamento di impostare \fBSIGCHLD\fP a \fBSIG_IGN\fP non specificato. Si noti che, anche se la disposizione predefinita di \fBSIGCHLD\fP è "ignore", impostarla esplicitamente a \fBSIG_IGN\fP comporterà un diverso trattamento dei processi figlio zombie). .PP Linux 2.6 è conforme a questa specifica. Tuttavia Linux 2.4 (e precedenti) non lo è: se una chiamata \fBwait\fP() o \fBwaitpid\fP() è effettuata mentre \fBSIGCHLD\fP è ignorato, la chiamata si comporta come se \fBSIGCHLD\fP non fosse stato ignorato, ovvero, la chiamata si blocca fino a quando il prossimo processo figlio termina e quindi restituisce l'ID del processo e lo stato di questo processo figlio. .SS "Note Linux" Nel kernel Linux un thread programmato dal kernel non è un costrutto distinto da un processo. Invece un thread è semplicemente un processo creato usando la chiamata esclusiva di Linux \fBclone\fP(2); altre routine come la chiamata portabile \fBpthread_create\fP(3) sono implementate usando \fBclone\fP(2). Prima di Linux 2.4 un thread era solo un caso speciale di un processo, e come conseguenza un thread non poteva aspettare il processo figlio di un altro thread, anche se l'ultimo apparteneva allo stesso gruppo del thread. Tuttavia POSIX prescrive tale funzionalità, e a partire da Linux 2.4 un thread può, e in modo predefinito lo fa, aspettare il processo figlio di un altro thread nello stesso gruppo del thread. .PP .\" commit 91c4e8ea8f05916df0c8a6f383508ac7c9e10dba Le seguenti \fIopzioni\fP specifiche di Linux devono essere usate con i figli creati usando \fBclone\fP(2); esse possono anche essere usate, a partire da Linux 4.07, con \fBwaitid\fP(): .TP \fB__WCLONE\fP .\" since 0.99pl10 Aspetta solo i figli di "clone". Se omessa allora aspetta solo i figli "non\-clone". (Un processo figlio "clone" è uno che non invia segnali, o un segnale diverso da \fBSIGCHLD\fP ai suoi genitori quando viene terminato). Questa opzione è ignorata se viene anche specificato \fB__WALL\fP. .TP \fB__WALL\fP (a partire da Linux 2.4) .\" since patch-2.3.48 Aspetta tutti i figli, qualunque sia il loro tipo ("clone" o "non\-clone"). .TP \fB__WNOTHREAD\fP (a partire da Linux 2.4) .\" since patch-2.4.0-test8 Non aspetta figli di altri thread nello stesso gruppo del thread. Questo era il comportamento predefinito prima di Linux 2.4. .PP .\" commit bf959931ddb88c4e4366e96dd22e68fa0db9527c .\" prevents cases where an unreapable zombie is created if .\" /sbin/init doesn't use __WALL. A partire da Linux 4.7, il flag \fB__WALL\fP è automaticamente sottinteso se il processo figlio è tracciato con ptrace. .SS "Differenze tra la libreria C e il kernel" \fBwait\fP() è in realtà una funzione di libreria che (in glibc) è implementata come una chiamata a \fBwait4\fP(2). .PP .\" e.g., i386 has the system call, but not x86-64 Su alcune architetture, non c'è nessuna chiamata di sistema \fBwaitpid\fP(); invece, questa interfaccia è implementata attraverso una funzione wrapper della libreria C che chiama \fBwait4\fP(2). .PP La chiamata di sistema diretta \fBwaitid\fP() accetta un quinto argomento, di tipo \fIstruct rusage\ *\fP. Se questo argomento non è NULL, viene usato per restituire informazioni sull'uso delle risorse del processofiglio, allo stesso modo di \fBwait4\fP(2). Vedere \fBgetrusage\fP(2) per i dettagli. .SH BUG Secondo POSIX.1\-2008, un'applicazione che chiama \fBwaitid\fP() deve assicurarsi che \fIinfop\fP punti ala struttura \fIsiginfo_t\fP (cioé, che sia un puntatore non\-NULL). Su Linux, se \fIinfop\fP è NULL, \fBwaitid\fP() va a buon fine, e ritorna l'ID di processo del processo figlio aspettato. Le applicazioni dovrebbero evitare di contare su questa caratteristica non conforme, non standard e non necessaria. .SH ESEMPI .\" fork.2 refers to this example program. Il seguente programma dimostra l'uso di \fBfork\fP(2) e \fBwaitpid\fP(). Il programma crea un processo figlio. Se dalla linea di comando non viene fornito alcun argomento al programma, allora il processo figlio sospende la propria esecuzione usando \fBpause\fP(2), per permettere all'utente di mandare il segnale al processo figlio. Altrimenti, se viene fornito un argomento dalla linea di comando, allora il processo figlio esce immediatamente, usando l'intero fornito dalla linea di comando come stato di uscita. Il processo genitore esegue un ciclo che controlla il processo figlio usando \fBwaitpid\fP(), e usa le macro W*() descritte sopra per analizzare il valore dello stato diattesa. .PP La seguente sessione di shell dimostra l'uso del programma: .PP .in +4n .EX $\fB ./a.out &\fP Child PID is 32360 [1] 32359 $\fB kill \-STOP 32360\fP stopped by signal 19 $\fB kill \-CONT 32360\fP continued $\fB kill \-TERM 32360\fP killed by signal 15 [1]+ Done ./a.out $ .EE .in .SS "Sorgente del programma" .\" SRC BEGIN (wait.c) \& .EX #include #include #include #include #include int main(int argc, char *argv[]) { int wstatus; pid_t cpid, w; cpid = fork(); if (cpid == \-1) { perror("fork"); exit(EXIT_FAILURE); } if (cpid == 0) { /* Codice eseguito dal processo figlio */ printf("Child PID is %jd\en", (intmax_t) getpid()); if (argc == 1) pause(); /* Aspetta i segnali */ _exit(atoi(argv[1])); } else { /* codice eseguito dal genitore */ do { w = waitpid(cpid, &wstatus, WUNTRACED | WCONTINUED); if (w == \-1) { perror("waitpid"); exit(EXIT_FAILURE); } if (WIFEXITED(wstatus)) { printf("exited, status=%d\en", WEXITSTATUS(wstatus)); } else if (WIFSIGNALED(wstatus)) { printf("killed by signal %d\en", WTERMSIG(wstatus)); } else if (WIFSTOPPED(wstatus)) { printf("stopped by signal %d\en", WSTOPSIG(wstatus)); } else if (WIFCONTINUED(wstatus)) { printf("continued\en"); } } while (!WIFEXITED(wstatus) && !WIFSIGNALED(wstatus)); exit(EXIT_SUCCESS); } } .EE .\" SRC END .SH "VEDERE ANCHE" \fB_exit\fP(2), \fBclone\fP(2), \fBfork\fP(2), \fBkill\fP(2), \fBptrace\fP(2), \fBsigaction\fP(2), \fBsignal\fP(2), \fBwait4\fP(2), \fBpthread_create\fP(3), \fBcore\fP(5), \fBcredentials\fP(7), \fBsignal\fP(7) .PP .SH TRADUZIONE La traduzione italiana di questa pagina di manuale è stata creata da Giulio Daprelà , Elisabetta Galli e Marco Curreli . .PP Questa traduzione è documentazione libera; leggere la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License Versione 3 .UE o successiva per le condizioni di copyright. Non ci assumiamo alcuna responsabilità. .PP Per segnalare errori nella traduzione di questa pagina di manuale inviare un messaggio a .MT pluto-ildp@lists.pluto.it .ME .