.\" -*- 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 "2 mei 2024" "Linux man\-pages 6.8" .SH NAAM wait, waitpid, waitid \- wacht op toestand verandering in een proces .SH BIBLIOTHEEK Standard C bibliotheek (\fIlibc\fP, \fI\-lc\fP) .SH SAMENVATTING .nf \fB#include \fP .P \fBpid_t wait(int *\fP\fIwstatus\fP\fB);\fP \fBpid_t waitpid(pid_t \fP\fIpid\fP\fB, int *_NULL_baar\fP\fIwstatus\fP\fB, int \fP\fIopties\fP\fB);\fP .P \fBint waitid(idtype_t \fP\fIidtype\fP\fB, id_t \fP\fIid\fP\fB, siginfo_t *\fP\fIinfop\fP\fB, int \fP\fIopties\fP\fB);\fP /* Dit is het glibc en POSIX interface; zie OPMERKING voor informatie over de ruwe systeem aanroep. */ .fi .P .RS -4 Feature Test Macro´s eisen in glibc (zie \fBfeature_test_macros\fP(7)): .RE .P \fBwaitid\fP(): .nf .\" (_XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED) Vanaf glibc 2.26: _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L glibc 2.25 en eerder: _XOPEN_SOURCE || /* Vanaf glibc 2.12: */ _POSIX_C_SOURCE >= 200809L || /* Glibc <= 2.19: */ _BSD_SOURCE .fi .SH BESCHRIJVING Al deze systeem aanroepen worden gebruikt om te wachten op een toestandsverandering in een kind van het aanroepende proces en verkrijgen informatie over het kind wiens toestand werd veranderd. Een toestandsverandering wordt gezien als: het kind werd beëindigd; het kind werd beëindigd door een signaal; of het kind werd hervat door een signaal. In het geval van een beëindigd kind, het uitvoeren van een "wacht" maakt het mogelijk dat het systeem de hulpbronnen die geassocieerd zijn met het kind kunnen vrijgeven; als de "wacht" niet wordt uitgevoerd, dan blijft het beëindigde kind een een "zombie" toestand (zie OPMERKINGEN hieronder). .P Als een kind al van toestand is veranderd, dan keren deze aanroepen meteen terug. Anders zouden ze blokkeren totdat een kind van toestand verandert of een signaal verwerker interrumpeert de aanroep (aannemende dat systeem aanroepen niet automatisch geherstart worden gebruik makende van de \fBSA_RESTART\fP vlag van \fBsigaction\fP(2)). In de rest van deze pagina:een kind waarvan de toestand werd veranderd en waarop niet gewacht werd door een van de systeem aanroepen wordt aangeduid als \fIwaitable\fP. .SS "wait() and waitpid()" De \fBwait\fP() systeem aanroep schort het uitvoeren van de huidige thread op totdat een van zijn kinderen eindigt. De aanroep \fIwait(&wstatus)\fP is equivalent aan: .P .in +4n .EX waitpid(\-1, &wstatus, 0); .EE .in .P De \fBwaitpid\fP() systeem aanroep schort het uitvoeren van de huidige thread op tot dat een kind gespecificeerd door \fIpid\fP argument is veranderd van toestand. Standaard wacht \fBwaitpid\fP() alleen op beëindigde kinderen, maar is dit gedrag aanpasbaar via het \fIopties\fP argument, zoals hieronder beschreven. .P De waarde van \fIpid\fP kan een van de volgende zijn: .TP < \fB\-1\fP wat betekend dat er gewacht wordt op elk kind proces van wie de proces groep ID gelijk is aan de absolute waarde van \fIpid\fP. .TP \fB\-1\fP wat betekent wacht op een kind proces. .TP \fB0\fP wat betekend dat er gewacht wordt op elk kind proces van wie het proces groep ID gelijk is aan dat van het aanroepende proces ten tijde van de aanroep van \fBwaitpid\fP(). .TP > \fB0\fP wat betekend dat er gewacht wordt op elk kind van wie het proces ID gelijk is aan de waarde van \fIpid\fP. .P De waarde van \fIopties\fP is een OF (incl.) van nul of meer van de volgende constanten: .TP \fBWNOHANG\fP betekend dat er onmiddellijk wordt teruggekeerd als geen kind beëindigd was. .TP \fBWUNTRACED\fP keer ook terug als het kind werd beëindigd (maar niet getraceerd via \fBptrace\fP(2)). In de status van \fItraced\fP kinderen die werden beëindigd wordt voorzien, zelfs als deze optie niet werd opgegeven. .TP \fBWCONTINUED\fP (sinds Linux 2.6.10) keer ook terug als een beëindigd kind werd hervat door het afleveren van \fBSIGCONT\fP. .P (Zie hieronder voor de alleen\-Linux opties.) .P Als \fIwstatus\fP niet NULL is, dan slaan \fBwait\fP() en \fBwaitpid\fP() status informatie op in de \fIint\fP naar welk het wijst. Dit geheel getal kan worden ingezien met de volgende macro´s (die het geheel getal zelf als argument gebruiken, niet de wijzer er naar toe, zoals gedaan in \fBwait\fP() en \fBwaitpid\fP()!): .TP \fBWIFEXITED(\fP\fIwstatus\fP\fB)\fP retourneert "waar" als het kind normaal beëindigde, dat is, door het aanroepen van \fBexit\fP(3) of \fB_exit\fP(2), of door terug te keren uit main(). .TP \fBWEXITSTATUS(\fP\fIwstatus\fP\fB)\fP retourneert de terugkeer status van het kind. Deze bestaat uit de minst belangrijke 8 bits van het \fIstatus\fP argument dat het kind specificeerde in een aanroep van \fBexit\fP(3) of \fB_exit\fP(2) of als het argument van een return statement in main(). Deze macro moet alleen gebruikt worden als \fBWIFEXITED\fP een "waar" terug gaf. .TP \fBWIFSIGNALED(\fP\fIwstatus\fP\fB)\fP geeft "waar" terug als het proces eindigde door een signaal. .TP \fBWTERMSIG(\fP\fIwstatus\fP\fB)\fP geeft het nummer van het signaal dat ervoor zorgde dat het kind proces eindigde. Deze macro kan alleen gebruikt worden als \fBWIFSIGNALED\fP "waar" terug gaf. .TP \fBWCOREDUMP(\fP\fIwstatus\fP\fB)\fP retourneert "waar" als het kind een core dump produceerde (zie \fBcore\fP(5)). Deze macro kan alleen gebruikt worden als \fBWIFSIGNALED\fP "waar" terug gaf. .IP Deze macro is niet gespecificeerd in POSIX.1\-2001 en is niet beschikbaar in enkele UNIX implementaties (b.v. AIX, SunOS). Daarom, sluit zijn gebruik binnen \fI#ifdef WCOREDUMP ... #endif\fP in. .TP \fBWIFSTOPPED(\fP\fIwstatus\fP\fB)\fP geeft "waar" terug als het kind proces werd beëindigd door het afleveren van een signaal; dit is alleen mogelijk als de aanroep werd gedaan met \fBWUNTRACED\fP of wanneer het kinderen wordt getraceerd (zie \fBptrace\fP(2)). .TP \fBWSTOPSIG(\fP\fIwstatus\fP\fB)\fP geeft het nummer van het signaal dat ervoor zorgde dat het kind stopte. Deze macro kan alleen afgehandeld worden als \fBWIFSTOPPED\fP ongelijk\-nul teruggaf. .TP \fBWIFCONTINUED(\fP\fIwstatus\fP\fB)\fP (vanaf Linux 2.6.10) geeft "waar" terug als het kind werd hervat door het aanleveren van \fBSIGCONT\fP. .SS waitid() De \fBwaitid\fP() systeem aanroep (beschikbaar vanaf Linux 2.6.9.) geeft preciezere controle over het wachten op toestandsveranderingen van kinderen .P De \fIidtype\fP en \fIid\fP argumenten selecteren de kind(eren) om op te wachten, als volgt: .TP \fIidtype\fP == \fBP_PID\fP Wacht op het kind wiens proces ID overeenkomt met \fIid\fP. .TP \fIidtype\fP == \fBP_PID\fP (vanaf Linux 5.4) .\" commit 3695eae5fee0605f316fbaad0b9e3de791d7dfaf Wacht op het kind gerefereerd door de PID bestands beschrijving gespecificeerd in \fIid\fP. (Zie \fBpidfd_open\fP(2) voor verdere informatie over PID bestands beschrijvers.) .TP \fIidtype\fP == \fBP_PGID\fP .\" commit 821cc7b0b205c0df64cce59aacc330af251fa8f7 Wacht op enig kind wiens proces groep ID overeenkomt met \fIid\fP. Vanaf Linux 5.4, als \fIid\fP is NUL, dan wacht op enig kind dat tot dezelfde proces groep zit als de proces groep van de aanroeper ten tijde van de aanroep. .TP \fIidtype\fP == \fBP_ALL\fP Wacht op enig kind; \fIid\fP wordt geïgnoreerd. .P De kind status veranderingen om te wachten worden gespecificeerd door OF´en van een of meer van de volgende vlaggen in \fIopties\fP: .TP \fBWEXITED\fP Wacht op kinderen die zijn beëindigd. .TP \fBWSTOPPED\fP Wacht op kinderen die zijn gestopt door het leveren van een signaal. .TP \fBWCONTINUED\fP Wacht op (eerder gestopte) kinderen die zijn hervat door het aanleveren van \fBSIGCONT\fP. .P De volgende vlaggen mogen additioneel worden geOF´d in \fIopties\fP: .TP \fBWNOHANG\fP Zoals voor \fBwaitpid\fP(). .TP \fBWNOWAIT\fP Laat het kind in een wachtbare status; een latere "wait"\-aanroep kan opnieuw gebruikt worden om de status van het kind op te vragen. .P Bij een succesvolle terugkeer, \fBwaitid\fP() vult de volgende velden van de \fIsiginfo_t\fP structure aangewezen door \fIinfop\fP: .TP \fIsi_pid\fP Het proces ID van het kind. .TP \fIsi_uid\fP Het effectieve gebruiker ID van het kind. (Dit veld is niet gezet op de meeste andere implementaties.) .TP \fIsi_signo\fP Altijd gezet op \fBSIGCHLD\fP. .TP \fIsi_status\fP Ofwel de retour status van het kind, zoals mee gegeven aan \fB_exit\fP(2) (of \fBexit\fP(3)), ofwel het signaal de veroorzaakte het kind te beëindigen, stoppen of doorgaan. Het \fIsi_code\fP veld kan worden gebruikt om te bepalen hoe dit veld te interpreteren. .TP \fIsi_code\fP Zet op een van: \fBCLD_EXITED\fP (kind roep aan \fB_exit\fP(2)); \fBCLD_KILLED\fP (kind beëindigd door signaal); \fBCLD_DUMPED\fP (kind beëindigd door signaal, en dumpte core); \fBCLD_STOPPED\fP (kind gestopt door signaal); \fBCLD_TRAPPED\fP (getraceerd kind zit vast); or \fBCLD_CONTINUED\fP (kind vervolgt door \fBSIGCONT\fP). .P Als \fBWNOHANG\fP werd opgegeven in \fIopties\fP en er waren geen kinderen in een wacht toestand, dan geeft \fBwaitid\fP() meteen 0 terug and de status van de \fIsiginfo_t\fP structure aangewezen door \fIinfop\fP hangt af van de implementatie. Om (overdraagbaar) dit geval te onderscheiden van die waar een kind zich in een wacht toestand bevond, maak dan het \fIsi_pid\fP veld nul voor de aanroep en controleer op een niet\-nul waarde in dit veld nadat de aanroep terugkeerde. .P .\" 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) voegt de eis toe dat wanneer \fBWNOHANG\fP werd gespecificeerd in \fIopties\fP en er waren geen kinderen wacht toestand, dan zou \fBwaitid\fP() de \fIsi_pid\fP en \fIsi_signo\fP velden nul moeten maken. Op Linux en andere implementaties die aan deze eis voldoen, is het niet noodzakelijk om het \fIsi_pid\fP veld nul te maken voor het aanroepen van \fBwaitid\fP(). Echter volgen niet alle implementaties de POSIX.1 specificatie op dit punt. .SH "EIND WAARDE" \fBwait\fP(): bij succes, retourneert het proces ID van het beëindigde kind; bij falen wordt een \-1 teruggegeven. .P \fBwaitpid\fP(): bij succes, retourneert het proces ID van het kind waarvan de status werd veranderd; als \fBWNOHANG\fP gebruikt werd en een of meer kind(eren) aangeduid door \fBpid\fP bestaan, maar hebben hun toestand niet verandert, dan wordt nul teruggegeven. Bij een fout wordt \-1 teruggegeven. .P .\" 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". \fBwaitpid\fP(): geeft 0 terug bij succes of als \fBWNOHANG\fP werd opgegeven en geen kind(eren) aangeduid door \fIid\fP is nog niet van toestand veranderd; bij een fout wordt \-1 teruggegeven. .P Bij falen, zal elk van deze aanroepen \fIerrno\fP zetten om de fout aan te duiden. .SH FOUTEN .TP \fBEAGAIN\fP De PID bestandsindicator gespecificeerd in \fIid\fP is niet\-blokkerend en het proces dat er naar verwijst werd niet beëindigd. .TP \fBECHILD\fP (voor \fBwait\fP()) Het aanroepende proces heeft geen enkel kind waarop gewacht wordt. .TP \fBECHILD\fP (voor \fBwaitpid\fP() of \fBwaitid\fP()) Het proces gespecificeerd door \fIpid\fP (\fBwaitpid\fP()) of \fIidtype\fP en \fIid\fP (\fBwaitid\fP()) bestaat niet of is geen kind van het aanroepende proces. (Dit kan gebeuren als het eigen kind als de actie voor \fBSIGCHLD\fP is gezet op \fBSIG_IGN\fP. Zie ook de \fILinux Opmerkingen\fP sectie over threads.) .TP \fBEINTR\fP \fBWNOHANG\fP was is niet gezet en een gedeblokkeerd signaal of een \fBSIGCHLD\fP werd ontvangen; zie \fBsignal\fP(7). .TP \fBEINVAL\fP Het \fIopties\fP argument was ongeldig. .TP \fBESRCH\fP (voor \fBwait\fP() of \fBwaitpid\fP()) \fIpid\fP is gelijk aan \fBINT_MIN\fP. .SH VERSIES .SS "C library/kernel verschillen" \fBwait\fP() is eigenlijk een bibliotheek functie die (in glibc) is geïmplementeerd als een aanroep naar \fBwait4\fP(2). .P .\" e.g., i386 has the system call, but not x86-64 Op sommige architecturen, is er geen \fBwaitpid\fP() systeem aanroep; in plaats daarvan, is dit interface geïmplementeerd door een C bibliotheek omwikkel functie die \fBwait4\fP(2) aanroept. .P De ruwe \fBwaitid\fP() systeem aanroep gebruikt het vijfde argument, van het type \fIstruct rusage\*\fP. Als dit argument niet\-NULL is, dan wordt het gebruikt om hulpbron informatie over het kind te retourneren, op dezelfde manier als \fBwait4\fP(2). Zie \fBgetrusage\fP(2) voor details. .SH "VOLDOET AAN" POSIX.1\-2008. .SH GESCHIEDENIS SVr4, 4.3BSD, POSIX.1\-2001. .SH OPMERKINGEN Een kind dat stopt, maar waar niet op gewacht is wordt een "zombie". De kernel onderhoudt een minimale verzameling van informatie over het zombie proces (PID, beëindiging status, hulpbron gebruik informatie) om de ouder in staat te stellen om later te wachten om de informatie over het kind te verkrijgen. Zolang de zombie niet werd verwijderd door te wachten, zal het een item in de proces tabel van de kernel in beslag nemen, en als deze tabel vol is, is het niet meer mogelijk om meer processen te creëren. Als een ouder proces beëindigd, dan zullen zijn "zombie"kinderen (als die er zijn) worden geadopteerd door \fBinit\fP(1), (of door het dichtstbijzijnde "maaimachine" proces zoals gedefinieerd door het gebruik van de \fBprctl\fP(2) \fBPR_SET_CHILD_SUBREAPER\fP operatie); \fBinit\fP(1) voert automatisch een wacht uit om zombies te verwijderen. .P POSIX.1\-2001 specificeert dat als een dispositie van \fBSIGCHLD\fP is gezet op \fBSIG_IGN\fP of de \fBSA_NOCLDWAIT\fP vlag is gezet voor \fBSIGCHLD\fP (zie \fBsigaction\fP(2)), dan zullen kinderen die eindigen geen zombies worden en een aanroep van \fBwait\fP() of \fBwaitpid\fP() zal blokkeren totdat alle kinderen beëindigd zijn, en vervolgens falen met \fIerrno\fP gezet op \fBECHILD\fP. (De originele POSIX standaard liet het gedrag van het zetten van \fBSIGCHLD\fP op \fBSIG_IGN\fP ongespecificeerd. Let op dat zelfs als de standaard dispositie van \fBSIGCHLD\fP "negeer" is, dan zal het expliciet zetten van de dispositie op \fBSIG_IGN\fP resulteren in een andere behandeling van zombie proces kinderen.) .P Linux 2.6 voldoet aan de POSIX eisen. Hoewel Linux 2.4 (en eerder) dat niet deed: als een \fBwait\fP() of \fBwaitpid\fP() aanroep wordt gedaan terwijl \fBSIGCHLD\fP wordt geïgnoreerd, dan gedraagt de aanroep zich alsof \fBSIGCHLD\fP niet geïgnoreerd werd, dat betekend, de aanroep blokkeert totdat het volgende kind stopt en vervolgens het proces ID en de status van dat kind teruggeeft. .SS "Linux notities" In de Linux kernel, een kernel\-thread is niet anders van constructie dan een proces. In plaats daarvan, is een thread eenvoudig weg een proces dat werd aangemaakt door de Linux\-unieke \fBclone\fP(2) systeem aanroep; andere routines zoals de overdraagbare \fBpthread_create\fP(3) aanroep zijn geïmplementeerd met \fBclone\fP(2). Voor Linux 2,4 was een thread slechts een speciaal geval van een proces, met als consequentie dat een thread niet kon wachten op kinderen of een andere thread, zelfs wanneer de laatste tot dezelfde thread groep behoorde. Echter, schrijft POSIX wel deze functionaliteit voor, en vanaf Linux 2.4 kan een thread, en doet dat ook standaard, wachten op kinderen of andere thread in dezelfde thread groep. .P .\" commit 91c4e8ea8f05916df0c8a6f383508ac7c9e10dba De volgende Linux\-specifieke \fIopties\fP zijn alleen van toepassing op kinderen aangemaakt door \fBclone\fP(2); die kunnen ook gebruikt worden, sinds Linux 4.7, met \fBwaitid\fP(): .TP \fB__WCLONE\fP .\" since 0.99pl10 Wacht alleen op "kloon" kinderen. Als weggelaten, wacht dan alleen op "niet\-kloon" kinderen. (Een "kloon"kind is er een dat geen signaal levert, of een signaal anders dan \fBSIGCHLD\fP aan zijn ouder bij beëindiging.) Deze optie wordt genegeerd als \fB_WALL\fP ook werd gespecificeerd. .TP \fB__WALL\fP (sinds Linux 2.4) .\" since patch-2.3.48 Wacht op alle kinderen, van welk type ("kloon" of "niet\-kloon") dan ook. .TP \fB__WNOTHREAD\fP (sinds Linux 2.4) .\" since patch-2.4.0-test8 Wacht niet op kinderen of andere threads in dezelfde thread groep. Dit was standaard voor Linux 2.4. .P .\" commit bf959931ddb88c4e4366e96dd22e68fa0db9527c .\" prevents cases where an unreapable zombie is created if .\" /sbin/init doesn't use __WALL. Vanaf Linux 4.7, is de \fB__WALL\fP vlag automatisch inbegrepen als het kind wordt ge\-"ptraced". .SH BUGS Volgens POSIX.1\-2008 moet een applicatie die \fBwaitid\fP() aanroept er voor zorgen dat \fIinfop\fP wijst naar een \fIsiginfo_t\fP structure (m.a.w. dat het een niet\-null wijzer is). Op Linux, als \fIinfop\fP gelijk is aan NULL, dan is \fBwaitid\fP() succesvol en retourneert het proces ID van het kind waarop gewacht wordt. Applicaties moeten vermijden op dit inconsistent, niet\-standaard en onnodige kenmerk te vertrouwen. .SH VOORBEELDEN .\" fork.2 refers to this example program. Het volgende programma demonstreert het gebruik van \fBfork\fP(2) en \fBwaitpid\fP(). Het programma creëert een kind proces. Als geen commando regel argument mee gegeven werd naar het programma, dan schort het kind zijn uitvoer op door \fBpause\fP(2) te gebruiken, om zo toe te staan dat de gebruiker signalen naar het kind kan sturen. Anders, als wel een commando regel argument werd mee gegeven, dan stop het kind onmiddellijk, en gebruikt het gehele getal mee gegeven op de commando regel als de uitvoer status. Het ouder proces voert een lus uit die het kind door gebruik van \fBwaitpid\fP() monitort, en gebruikt de W*() macros, zoals hierboven beschreven, om de wacht status waarde te analyseren. .P De volgend shell sessie demonstreert het gebruik van het programma: .P .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 "Programma bron" .\" SRC BEGIN (wait.c) \& .EX #include #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) { /* Code executed by child */ printf("Child PID is %jd\en", (intmax_t) getpid()); if (argc == 1) pause(); /* Wait for signals */ _exit(atoi(argv[1])); \& } else { /* Code executed by parent */ 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 "ZIE OOK" \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 VERTALING De Nederlandse vertaling van deze handleiding is geschreven door Jos Boersema , Mario Blättermann en Luc Castermans . .PP Deze vertaling is vrije documentatie; lees de .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License Version 3 .UE of later over de Copyright-voorwaarden. Er is geen AANSPRAKELIJKHEID. .PP Indien U fouten in de vertaling van deze handleiding zou vinden, stuur een e-mail naar .MT debian-l10n-dutch@lists.debian.org .ME .