View Source: wait(2) - Waikato Linux Users Group

Edit PageHistory Diff Info LikePages
WAIT
!!!WAIT
NAME
SYNOPSIS
DESCRIPTION
RETURN VALUE
ERRORS
NOTES
CONFORMING TO
SEE ALSO
----
!!NAME


wait, waitpid - wait for process termination
!!SYNOPSIS


__#include __
#include __


__pid_t wait(int *__''status''__)
pid_t waitpid(pid_t__ ''pid''__, int
*__''status''__, int__
''options''__);__
!!DESCRIPTION


The __wait__ function suspends execution of the current
process until a child has exited, or until a signal is
delivered whose action is to terminate the current process
or to call a signal handling function. If a child has
already exited by the time of the call (a so-called
__


The __waitpid__ function suspends execution of the
current process until a child as specified by the ''pid''
argument has exited, or until a signal is delivered whose
action is to terminate the current process or to call a
signal handling function. If a child as requested by
''pid'' has already exited by the time of the call (a
so-called
''


The value of ''pid'' can be one of:




which means to wait for any child process whose process
group ID is equal to the absolute value of
''pid''.


-1


which means to wait for any child process; this is the same
behaviour which __wait__ exhibits.


0


which means to wait for any child process whose process
group ID is equal to that of the calling
process.




which means to wait for the child whose process ID is equal
to the value of ''pid''.


The value of ''options'' is an OR of zero or more of the
following constants:


__WNOHANG__


which means to return immediately if no child has
exited.


__WUNTRACED__


which means to also return for children which are stopped,
and whose status has not been reported.


If ''status'' is not __NULL__, __wait__ or
__waitpid__ store status information in the location
pointed to by ''status''.


This status can be evaluated with the following macros
(these macros take the stat buffer (an __int__) as an
argument -- not a pointer to the buffer!):


__WIFEXITED(__''status''__)__


is non-zero if the child exited normally.


__WEXITSTATUS(__''status''__)__


evaluates to the least significant eight bits of the return
code of the child which terminated, which may have been set
as the argument to a call to __exit()__ or as the
argument for a __return__ statement in the main program.
This macro can only be evaluated if __WIFEXITED__
returned non-zero.


__WIFSIGNALED(__''status''__)__


returns true if the child process exited because of a signal
which was not caught.


__WTERMSIG(__''status''__)__


returns the number of the signal that caused the child
process to terminate. This macro can only be evaluated if
__WIFSIGNALED__ returned non-zero.


__WIFSTOPPED(__''status''__)__


returns true if the child process which caused the return is
currently stopped; this is only possible if the call was
done using __WUNTRACED__.


__WSTOPSIG(__''status''__)__


returns the number of the signal which caused the child to
stop. This macro can only be evaluated if __WIFSTOPPED__
returned non-zero.


Some versions of Unix (e.g. Linux, Solaris, but not AIX,
SunOS) also define a macro
__WCOREDUMP(__''status''__)__ to test whether the
child process dumped core. Only use this enclosed in #ifdef
WCOREDUMP ... #endif.
!!RETURN VALUE


The process ID of the child which exited, or zero if
__WNOHANG__ was used and no child was available, or -1 on
error (in which case ''errno'' is set to an appropriate
value).
!!ERRORS


__ECHILD__


if the process specified in ''pid'' does not exist or is
not a child of the calling process. (This can happen for
one's own child if the action for SIGCHLD is set to SIG_IGN.
See also the NOTES section about threads.)


__EINVAL__


if the ''options'' argument was invalid.


__EINTR__


if __WNOHANG__ was not set and an unblocked signal or a
__SIGCHLD__ was caught.
!!NOTES


The Single Unix Specification describes a flag SA_NOCLDWAIT
(not present under Linux) such that if either this flag is
set, or the action for SIGCHLD is set to SIG_IGN (which, by
the way, is not allowed by POSIX), then children that exit
do not become zombies and a call to ''wait()'' or
''waitpid()'' will block until all children have exited,
and then fail with ''errno'' set to ECHILD.


In the Linux kernel, a kernel-scheduled thread is not a
distinct construct from a process. Instead, a thread is
simply a process that is created using the Linux-unique
clone(2) system call; other routines such as the portable
pthread_create(3) call are implemented using
clone(2). Thus, if two threads A and B are siblings,
then thread A cannot wait on any processes forked by thread
B or its descendents, because an uncle cannot wait on his
nephews. In some other Unix-like systems, where multiple
threads are implemented as belonging to a single process,
thread A can wait on any processes forked by sibling thread
B; you will have to rewrite any code that makes this
assumption for it to work on Linux.
!!CONFORMING TO


SVr4, POSIX.1
!!SEE ALSO


clone(2), signal(2), wait4(2),
pthread_create(3), signal(7)
----
17 pages link to wait(2):
This page is a man page (or other imported legacy content). We are unable to automatically determine the license status of this page.
Last edited on Tuesday, June 4, 2002 12:23:49 am by "perry"
Edit PageHistory Diff Info LikePages