lib/glibc
lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-05-31 15:01:17 +03:00
Code

posix: Refactor tst-waitid (BZ #14666)

Browse Source 
The main changes are:

  - Adapt to libsupport.
  - Synchronize the signal handler using atomics.
  - Replace waitpid by waitid calls.
  - Use support_process_state_wait to wait for child state.
  - Add tests for P_PGID and P_ALL.
  - Use sigwaitinfo instead of global state set by the signal handler.

Checked on x86_64-linux-gnu and i686-linux-gnu.
This commit is contained in:
Adhemerval Zanella 2019-11-19 17:21:26 -03:00
parent dfe9aa9156
commit b3b6a40ab9
1 changed files with 158 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

559
posix/tst-waitid.c
View File

@ -22,13 +22,20 @@
#include <unistd.h> #include <unistd.h>
#include <sys/wait.h> #include <sys/wait.h>
#include <signal.h> #include <signal.h>
#include <time.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <support/xsignal.h>
#include <support/xunistd.h>
#include <support/check.h>
#include <support/process_state.h>
static void static void
test_child (void) test_child (bool setgroup)
{ {
/* Wait a second to be sure the parent set his variables before we if (setgroup)
produce a SIGCHLD. */ TEST_COMPARE (setpgid (0, 0), 0);
sleep (1);
/* First thing, we stop ourselves. */ /* First thing, we stop ourselves. */
raise (SIGSTOP); raise (SIGSTOP);
@ -44,475 +51,225 @@ test_child (void)
# define WSTOPPED WUNTRACED # define WSTOPPED WUNTRACED
#endif #endif
static sig_atomic_t expecting_sigchld, spurious_sigchld; /* Set with only SIGCHLD on do_test_waitid. */
#ifdef SA_SIGINFO static sigset_t chldset;
static siginfo_t sigchld_info;
#ifdef SA_SIGINFO
static void static void
sigchld (int signo, siginfo_t *info, void *ctx) sigchld (int signo, siginfo_t *info, void *ctx)
{ {
if (signo != SIGCHLD)
{
printf ("SIGCHLD handler got signal %d instead!\n", signo);
_exit (EXIT_FAILURE);
}
if (! expecting_sigchld)
{
spurious_sigchld = 1;
printf ("spurious SIGCHLD: signo %d code %d status %d pid %d\n",
info->si_signo, info->si_code, info->si_status, info->si_pid);
}
else
{
sigchld_info = *info;
expecting_sigchld = 0;
}
} }
#endif
static void static void
check_sigchld (const char *phase, int *ok, int code, int status, pid_t pid) check_sigchld (int code, int status, pid_t pid)
{
if (expecting_sigchld)
{
printf ("missing SIGCHLD on %s\n", phase);
*ok = EXIT_FAILURE;
expecting_sigchld = 0;
return;
}
if (sigchld_info.si_signo != SIGCHLD)
{
printf ("SIGCHLD for %s signal %d\n", phase, sigchld_info.si_signo);
*ok = EXIT_FAILURE;
}
if (sigchld_info.si_code != code)
{
printf ("SIGCHLD for %s code %d\n", phase, sigchld_info.si_code);
*ok = EXIT_FAILURE;
}
if (sigchld_info.si_status != status)
{
printf ("SIGCHLD for %s status %d\n", phase, sigchld_info.si_status);
*ok = EXIT_FAILURE;
}
if (sigchld_info.si_pid != pid)
{
printf ("SIGCHLD for %s pid %d\n", phase, sigchld_info.si_pid);
*ok = EXIT_FAILURE;
}
}
# define CHECK_SIGCHLD(phase, code_check, status_check) \
check_sigchld ((phase), &status, (code_check), (status_check), pid)
#else
# define CHECK_SIGCHLD(phase, code, status) ((void) 0)
#endif
static int
do_test (int argc, char *argv[])
{ {
#ifdef SA_SIGINFO #ifdef SA_SIGINFO
struct sigaction sa; siginfo_t siginfo;
sa.sa_flags = SA_SIGINFO|SA_RESTART; TEST_COMPARE (sigwaitinfo (&chldset, &siginfo), SIGCHLD);
sa.sa_sigaction = &sigchld;
if (sigemptyset (&sa.sa_mask) < 0 || sigaction (SIGCHLD, &sa, NULL) < 0) TEST_COMPARE (siginfo.si_signo, SIGCHLD);
{ TEST_COMPARE (siginfo.si_code, code);
printf ("setting SIGCHLD handler: %m\n"); TEST_COMPARE (siginfo.si_status, status);
return EXIT_FAILURE; TEST_COMPARE (siginfo.si_pid, pid);
}
#endif #endif
}
expecting_sigchld = 1; static int
do_test_waitd_common (idtype_t type, pid_t pid)
{
/* Adding process_state_tracing_stop ('t') allows the test to work under
trace programs such as ptrace. */
enum support_process_state stop_state = support_process_state_stopped
| support_process_state_tracing_stop;
pid_t pid = fork (); support_process_state_wait (pid, stop_state);
if (pid < 0)
{
printf ("fork: %m\n");
return EXIT_FAILURE;
}
else if (pid == 0)
{
test_child ();
_exit (127);
}
int status = EXIT_SUCCESS; check_sigchld (CLD_STOPPED, SIGSTOP, pid);
#define RETURN(ok) \
do { if (status == EXIT_SUCCESS) status = (ok); goto out; } while (0)
/* Give the child a chance to stop. */
sleep (3);
CHECK_SIGCHLD ("stopped (before waitid)", CLD_STOPPED, SIGSTOP);
/* Now try a wait that should not succeed. */ /* Now try a wait that should not succeed. */
siginfo_t info; siginfo_t info;
int fail;
info.si_signo = 0; /* A successful call sets it to SIGCHLD. */ info.si_signo = 0; /* A successful call sets it to SIGCHLD. */
int fail = waitid (P_PID, pid, &info, WEXITED|WCONTINUED|WNOHANG); fail = waitid (P_PID, pid, &info, WEXITED|WCONTINUED|WNOHANG);
switch (fail) if (fail == -1 && errno == ENOTSUP)
{ FAIL_RET ("waitid WNOHANG on stopped: %m");
default: TEST_COMPARE (fail, 0);
printf ("waitid returned bogus value %d\n", fail); TEST_COMPARE (info.si_signo, 0);
RETURN (EXIT_FAILURE);
case -1:
printf ("waitid WNOHANG on stopped: %m\n");
RETURN (errno == ENOTSUP ? EXIT_SUCCESS : EXIT_FAILURE);
case 0:
if (info.si_signo == 0)
break;
if (info.si_signo == SIGCHLD)
printf ("waitid WNOHANG on stopped status %d\n", info.si_status);
else
printf ("waitid WNOHANG on stopped signal %d\n", info.si_signo);
RETURN (EXIT_FAILURE);
}
/* Next the wait that should succeed right away. */ /* Next the wait that should succeed right away. */
info.si_signo = 0; /* A successful call sets it to SIGCHLD. */ info.si_signo = 0; /* A successful call sets it to SIGCHLD. */
info.si_pid = -1; info.si_pid = -1;
info.si_status = -1; info.si_status = -1;
fail = waitid (P_PID, pid, &info, WSTOPPED|WNOHANG); fail = waitid (P_PID, pid, &info, WSTOPPED|WNOHANG);
switch (fail) if (fail == -1 && errno == ENOTSUP)
{ FAIL_RET ("waitid WNOHANG on stopped: %m");
default: TEST_COMPARE (fail, 0);
printf ("waitid WSTOPPED|WNOHANG returned bogus value %d\n", fail); TEST_COMPARE (info.si_signo, SIGCHLD);
RETURN (EXIT_FAILURE); TEST_COMPARE (info.si_code, CLD_STOPPED);
case -1: TEST_COMPARE (info.si_status, SIGSTOP);
printf ("waitid WSTOPPED|WNOHANG on stopped: %m\n"); TEST_COMPARE (info.si_pid, pid);
RETURN (errno == ENOTSUP ? EXIT_SUCCESS : EXIT_FAILURE);
case 0:
if (info.si_signo != SIGCHLD)
{
printf ("waitid WSTOPPED|WNOHANG on stopped signal %d\n",
info.si_signo);
RETURN (EXIT_FAILURE);
}
if (info.si_code != CLD_STOPPED)
{
printf ("waitid WSTOPPED|WNOHANG on stopped code %d\n",
info.si_code);
RETURN (EXIT_FAILURE);
}
if (info.si_status != SIGSTOP)
{
printf ("waitid WSTOPPED|WNOHANG on stopped status %d\n",
info.si_status);
RETURN (EXIT_FAILURE);
}
if (info.si_pid != pid)
{
printf ("waitid WSTOPPED|WNOHANG on stopped pid %d != %d\n",
info.si_pid, pid);
RETURN (EXIT_FAILURE);
}
}
expecting_sigchld = WCONTINUED != 0;
if (kill (pid, SIGCONT) != 0) if (kill (pid, SIGCONT) != 0)
{ FAIL_RET ("kill (%d, SIGCONT): %m\n", pid);
printf ("kill (%d, SIGCONT): %m\n", pid);
RETURN (EXIT_FAILURE);
}
/* Wait for the child to have continued. */ /* Wait for the child to have continued. */
sleep (2); support_process_state_wait (pid, support_process_state_sleeping);
#if WCONTINUED != 0 #if WCONTINUED != 0
if (expecting_sigchld) check_sigchld (CLD_CONTINUED, SIGCONT, pid);
{
printf ("no SIGCHLD seen for SIGCONT (optional)\n");
expecting_sigchld = 0;
}
else
CHECK_SIGCHLD ("continued (before waitid)", CLD_CONTINUED, SIGCONT);
info.si_signo = 0; /* A successful call sets it to SIGCHLD. */ info.si_signo = 0; /* A successful call sets it to SIGCHLD. */
info.si_pid = -1; info.si_pid = -1;
info.si_status = -1; info.si_status = -1;
fail = waitid (P_PID, pid, &info, WCONTINUED|WNOWAIT); fail = waitid (P_PID, pid, &info, WCONTINUED|WNOWAIT);
switch (fail) if (fail == -1 && errno == ENOTSUP)
{ FAIL_RET ("waitid WCONTINUED|WNOWAIT on continued: %m");
default: TEST_COMPARE (fail, 0);
printf ("waitid WCONTINUED|WNOWAIT returned bogus value %d\n", fail); TEST_COMPARE (info.si_signo, SIGCHLD);
RETURN (EXIT_FAILURE); TEST_COMPARE (info.si_code, CLD_CONTINUED);
case -1: TEST_COMPARE (info.si_status, SIGCONT);
printf ("waitid WCONTINUED|WNOWAIT on continued: %m\n"); TEST_COMPARE (info.si_pid, pid);
RETURN (errno == ENOTSUP ? EXIT_SUCCESS : EXIT_FAILURE);
case 0:
if (info.si_signo != SIGCHLD)
{
printf ("waitid WCONTINUED|WNOWAIT on continued signal %d\n",
info.si_signo);
RETURN (EXIT_FAILURE);
}
if (info.si_code != CLD_CONTINUED)
{
printf ("waitid WCONTINUED|WNOWAIT on continued code %d\n",
info.si_code);
RETURN (EXIT_FAILURE);
}
if (info.si_status != SIGCONT)
{
printf ("waitid WCONTINUED|WNOWAIT on continued status %d\n",
info.si_status);
RETURN (EXIT_FAILURE);
}
if (info.si_pid != pid)
{
printf ("waitid WCONTINUED|WNOWAIT on continued pid %d != %d\n",
info.si_pid, pid);
RETURN (EXIT_FAILURE);
}
}
/* That should leave the CLD_CONTINUED state waiting to be seen again. */ /* That should leave the CLD_CONTINUED state waiting to be seen again. */
info.si_signo = 0; /* A successful call sets it to SIGCHLD. */ info.si_signo = 0; /* A successful call sets it to SIGCHLD. */
info.si_pid = -1; info.si_pid = -1;
info.si_status = -1; info.si_status = -1;
fail = waitid (P_PID, pid, &info, WCONTINUED); fail = waitid (P_PID, pid, &info, WCONTINUED);
switch (fail) if (fail == -1 && errno == ENOTSUP)
{ FAIL_RET ("waitid WCONTINUED on continued: %m");
default: TEST_COMPARE (fail, 0);
printf ("waitid WCONTINUED returned bogus value %d\n", fail); TEST_COMPARE (info.si_signo, SIGCHLD);
RETURN (EXIT_FAILURE); TEST_COMPARE (info.si_code, CLD_CONTINUED);
case -1: TEST_COMPARE (info.si_status, SIGCONT);
printf ("waitid WCONTINUED on continued: %m\n"); TEST_COMPARE (info.si_pid, pid);
RETURN (errno == ENOTSUP ? EXIT_SUCCESS : EXIT_FAILURE);
case 0:
if (info.si_signo != SIGCHLD)
{
printf ("waitid WCONTINUED on continued signal %d\n", info.si_signo);
RETURN (EXIT_FAILURE);
}
if (info.si_code != CLD_CONTINUED)
{
printf ("waitid WCONTINUED on continued code %d\n", info.si_code);
RETURN (EXIT_FAILURE);
}
if (info.si_status != SIGCONT)
{
printf ("waitid WCONTINUED on continued status %d\n",
info.si_status);
RETURN (EXIT_FAILURE);
}
if (info.si_pid != pid)
{
printf ("waitid WCONTINUED on continued pid %d != %d\n",
info.si_pid, pid);
RETURN (EXIT_FAILURE);
}
}
/* Now try a wait that should not succeed. */ /* Now try a wait that should not succeed. */
info.si_signo = 0; /* A successful call sets it to SIGCHLD. */ info.si_signo = 0; /* A successful call sets it to SIGCHLD. */
fail = waitid (P_PID, pid, &info, WCONTINUED|WNOHANG); fail = waitid (P_PID, pid, &info, WCONTINUED|WNOHANG);
switch (fail) if (fail == -1 && errno == ENOTSUP)
{ FAIL_RET ("waitid WCONTINUED|WNOHANG on waited continued: %m");
default: TEST_COMPARE (fail, 0);
printf ("waitid returned bogus value %d\n", fail); TEST_COMPARE (info.si_signo, 0);
RETURN (EXIT_FAILURE);
case -1:
printf ("waitid WCONTINUED|WNOHANG on waited continued: %m\n");
RETURN (errno == ENOTSUP ? EXIT_SUCCESS : EXIT_FAILURE);
case 0:
if (info.si_signo == 0)
break;
if (info.si_signo == SIGCHLD)
printf ("waitid WCONTINUED|WNOHANG on waited continued status %d\n",
info.si_status);
else
printf ("waitid WCONTINUED|WNOHANG on waited continued signal %d\n",
info.si_signo);
RETURN (EXIT_FAILURE);
}
/* Now stop him again and test waitpid with WCONTINUED. */ /* Now stop him again and test waitpid with WCONTINUED. */
expecting_sigchld = 1;
if (kill (pid, SIGSTOP) != 0) if (kill (pid, SIGSTOP) != 0)
{ FAIL_RET ("kill (%d, SIGSTOP): %m\n", pid);
printf ("kill (%d, SIGSTOP): %m\n", pid);
RETURN (EXIT_FAILURE);
}
/* Give the child a chance to stop. The waitpid call below will block /* Wait the child stop. The waitid call below will block until it has
until it has stopped, but if we are real quick and enter the waitpid stopped, but if we are real quick and enter the waitid system call
system call before the SIGCHLD has been generated, then it will be before the SIGCHLD has been generated, then it will be discarded and
discarded and never delivered. */ never delivered. */
sleep (3); support_process_state_wait (pid, stop_state);
pid_t wpid = waitpid (pid, &fail, WUNTRACED); fail = waitid (type, pid, &info, WEXITED|WSTOPPED);
if (wpid < 0) TEST_COMPARE (fail, 0);
{ TEST_COMPARE (info.si_signo, SIGCHLD);
printf ("waitpid WUNTRACED on stopped: %m\n"); TEST_COMPARE (info.si_code, CLD_STOPPED);
RETURN (EXIT_FAILURE); TEST_COMPARE (info.si_status, SIGSTOP);
} TEST_COMPARE (info.si_pid, pid);
else if (wpid != pid)
{ check_sigchld (CLD_STOPPED, SIGSTOP, pid);
printf ("waitpid WUNTRACED on stopped returned %d != %d (status %x)\n",
wpid, pid, fail);
RETURN (EXIT_FAILURE);
}
else if (!WIFSTOPPED (fail) || WIFSIGNALED (fail) || WIFEXITED (fail)
|| WIFCONTINUED (fail) || WSTOPSIG (fail) != SIGSTOP)
{
printf ("waitpid WUNTRACED on stopped: status %x\n", fail);
RETURN (EXIT_FAILURE);
}
CHECK_SIGCHLD ("stopped (after waitpid)", CLD_STOPPED, SIGSTOP);
expecting_sigchld = 1;
if (kill (pid, SIGCONT) != 0) if (kill (pid, SIGCONT) != 0)
{ FAIL_RET ("kill (%d, SIGCONT): %m\n", pid);
printf ("kill (%d, SIGCONT): %m\n", pid);
RETURN (EXIT_FAILURE);
}
/* Wait for the child to have continued. */ /* Wait for the child to have continued. */
sleep (2); support_process_state_wait (pid, support_process_state_sleeping);
if (expecting_sigchld) check_sigchld (CLD_CONTINUED, SIGCONT, pid);
{
printf ("no SIGCHLD seen for SIGCONT (optional)\n");
expecting_sigchld = 0;
}
else
CHECK_SIGCHLD ("continued (before waitpid)", CLD_CONTINUED, SIGCONT);
wpid = waitpid (pid, &fail, WCONTINUED); fail = waitid (type, pid, &info, WCONTINUED);
if (wpid < 0) TEST_COMPARE (fail, 0);
{ TEST_COMPARE (info.si_signo, SIGCHLD);
if (errno == EINVAL) TEST_COMPARE (info.si_code, CLD_CONTINUED);
printf ("waitpid does not support WCONTINUED\n"); TEST_COMPARE (info.si_status, SIGCONT);
else TEST_COMPARE (info.si_pid, pid);
{
printf ("waitpid WCONTINUED on continued: %m\n");
RETURN (EXIT_FAILURE);
}
}
else if (wpid != pid)
{
printf ("\
waitpid WCONTINUED on continued returned %d != %d (status %x)\n",
wpid, pid, fail);
RETURN (EXIT_FAILURE);
}
else if (WIFSTOPPED (fail) || WIFSIGNALED (fail) || WIFEXITED (fail)
|| !WIFCONTINUED (fail))
{
printf ("waitpid WCONTINUED on continued: status %x\n", fail);
RETURN (EXIT_FAILURE);
}
#endif #endif
expecting_sigchld = 1;
/* Die, child, die! */ /* Die, child, die! */
if (kill (pid, SIGKILL) != 0) if (kill (pid, SIGKILL) != 0)
{ FAIL_RET ("kill (%d, SIGKILL): %m\n", pid);
printf ("kill (%d, SIGKILL): %m\n", pid);
RETURN (EXIT_FAILURE);
}
#ifdef WNOWAIT #ifdef WNOWAIT
info.si_signo = 0; /* A successful call sets it to SIGCHLD. */ info.si_signo = 0; /* A successful call sets it to SIGCHLD. */
info.si_pid = -1; info.si_pid = -1;
info.si_status = -1; info.si_status = -1;
fail = waitid (P_PID, pid, &info, WEXITED|WNOWAIT); fail = waitid (type, pid, &info, WEXITED|WNOWAIT);
switch (fail) if (fail == -1 && errno == ENOTSUP)
{ FAIL_RET ("waitid WNOHANG on killed: %m");
default: TEST_COMPARE (fail, 0);
printf ("waitid WNOWAIT returned bogus value %d\n", fail); TEST_COMPARE (info.si_signo, SIGCHLD);
RETURN (EXIT_FAILURE); TEST_COMPARE (info.si_code, CLD_KILLED);
case -1: TEST_COMPARE (info.si_status, SIGKILL);
printf ("waitid WNOWAIT on killed: %m\n"); TEST_COMPARE (info.si_pid, pid);
RETURN (errno == ENOTSUP ? EXIT_SUCCESS : EXIT_FAILURE);
case 0:
if (info.si_signo != SIGCHLD)
{
printf ("waitid WNOWAIT on killed signal %d\n", info.si_signo);
RETURN (EXIT_FAILURE);
}
if (info.si_code != CLD_KILLED)
{
printf ("waitid WNOWAIT on killed code %d\n", info.si_code);
RETURN (EXIT_FAILURE);
}
if (info.si_status != SIGKILL)
{
printf ("waitid WNOWAIT on killed status %d\n", info.si_status);
RETURN (EXIT_FAILURE);
}
if (info.si_pid != pid)
{
printf ("waitid WNOWAIT on killed pid %d != %d\n", info.si_pid, pid);
RETURN (EXIT_FAILURE);
}
}
#else #else
/* Allow enough time to be sure the child died; we didn't synchronize. */ support_process_state_wait (pid, support_process_state_zombie);
sleep (2);
#endif #endif
check_sigchld (CLD_KILLED, SIGKILL, pid);
CHECK_SIGCHLD ("killed", CLD_KILLED, SIGKILL);
info.si_signo = 0; /* A successful call sets it to SIGCHLD. */ info.si_signo = 0; /* A successful call sets it to SIGCHLD. */
info.si_pid = -1; info.si_pid = -1;
info.si_status = -1; info.si_status = -1;
fail = waitid (P_PID, pid, &info, WEXITED|WNOHANG); fail = waitid (type, pid, &info, WEXITED | WNOHANG);
switch (fail) TEST_COMPARE (fail, 0);
{ TEST_COMPARE (info.si_signo, SIGCHLD);
default: TEST_COMPARE (info.si_code, CLD_KILLED);
printf ("waitid WNOHANG returned bogus value %d\n", fail); TEST_COMPARE (info.si_status, SIGKILL);
RETURN (EXIT_FAILURE); TEST_COMPARE (info.si_pid, pid);
case -1:
printf ("waitid WNOHANG on killed: %m\n");
RETURN (EXIT_FAILURE);
case 0:
if (info.si_signo != SIGCHLD)
{
printf ("waitid WNOHANG on killed signal %d\n", info.si_signo);
RETURN (EXIT_FAILURE);
}
if (info.si_code != CLD_KILLED)
{
printf ("waitid WNOHANG on killed code %d\n", info.si_code);
RETURN (EXIT_FAILURE);
}
if (info.si_status != SIGKILL)
{
printf ("waitid WNOHANG on killed status %d\n", info.si_status);
RETURN (EXIT_FAILURE);
}
if (info.si_pid != pid)
{
printf ("waitid WNOHANG on killed pid %d != %d\n", info.si_pid, pid);
RETURN (EXIT_FAILURE);
}
}
fail = waitid (P_PID, pid, &info, WEXITED); fail = waitid (P_PID, pid, &info, WEXITED);
if (fail == -1) TEST_COMPARE (fail, -1);
{ TEST_COMPARE (errno, ECHILD);
if (errno != ECHILD)
{
printf ("waitid WEXITED on killed: %m\n");
RETURN (EXIT_FAILURE);
}
}
else
{
printf ("waitid WEXITED returned bogus value %d\n", fail);
RETURN (EXIT_FAILURE);
}
#undef RETURN return 0;
out:
if (spurious_sigchld)
status = EXIT_FAILURE;
signal (SIGCHLD, SIG_IGN);
kill (pid, SIGKILL); /* Make sure it's dead if we bailed early. */
return status;
} }
#include "../test-skeleton.c" static int
do_test_waitid (idtype_t type)
{
#ifdef SA_SIGINFO
{
struct sigaction sa;
sa.sa_flags = SA_SIGINFO | SA_RESTART;
sa.sa_sigaction = sigchld;
sigemptyset (&sa.sa_mask);
xsigaction (SIGCHLD, &sa, NULL);
}
#endif
sigemptyset (&chldset);
sigaddset (&chldset, SIGCHLD);
/* The SIGCHLD shall has blocked at the time of the call to sigwait;
otherwise, the behavior is undefined. */
sigprocmask (SIG_BLOCK, &chldset, NULL);
pid_t pid = xfork ();
if (pid == 0)
{
test_child (type == P_PGID || type == P_ALL);
_exit (127);
}
int ret = do_test_waitd_common (type, pid);
xsignal (SIGCHLD, SIG_IGN);
kill (pid, SIGKILL); /* Make sure it's dead if we bailed early. */
return ret;
}
static int
do_test (void)
{
int ret = 0;
ret |= do_test_waitid (P_PID);
ret |= do_test_waitid (P_PGID);
ret |= do_test_waitid (P_ALL);
return ret;
}
#include <support/test-driver.c>