1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/* Helper file for tst-{atexit,at_quick_exit,cxa_atexit,on_exit}.
Copyright (C) 2017-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
/* http://pubs.opengroup.org/onlinepubs/000095399/functions/atexit.html
requires that we support at least 32 atexit handlers.
The number we actually support is limited by memory. Here we simply
check that we support at least the minimum required. */
#define MAX_ATEXIT 32
/* Arbitrary sequence matching current registrations. */
const char expected[] = "00000000000000000000000003021121130211";
static char crumbs[sizeof (expected)];
static int next_slot = 0;
/* Helper: flush stdout and _exit. */
static void
_exit_with_flush (int code)
{
fflush (stdout);
_exit (code);
}
static void
fn0 (void)
{
crumbs[next_slot++] = '0';
}
static void
fn1 (void)
{
crumbs[next_slot++] = '1';
}
static void
fn2 (void)
{
crumbs[next_slot++] = '2';
ATEXIT (fn1);
}
static void
fn3 (void)
{
crumbs[next_slot++] = '3';
ATEXIT (fn2);
ATEXIT (fn0);
}
static void
fn_final (void)
{
if (strcmp (crumbs, expected) == 0)
_exit_with_flush (0);
printf ("crumbs: %s\n", crumbs);
printf ("expected: %s\n", expected);
_exit_with_flush (1);
}
static int
do_test (void)
{
int slots_remaining = MAX_ATEXIT;
/* Register this first so it can verify expected order of the rest. */
ATEXIT (fn_final); --slots_remaining;
ATEXIT (fn1); --slots_remaining;
ATEXIT (fn3); --slots_remaining;
ATEXIT (fn1); --slots_remaining;
ATEXIT (fn2); --slots_remaining;
ATEXIT (fn1); --slots_remaining;
ATEXIT (fn3); --slots_remaining;
/* Fill the rest of available slots with fn0. */
while (slots_remaining > 0)
{
ATEXIT (fn0); --slots_remaining;
}
/* Verify that handlers registered above are inherited across fork. */
const pid_t child = fork ();
switch (child)
{
case -1:
printf ("fork: %m\n");
_exit_with_flush (3);
case 0: /* Child. */
break;
default:
{
int status;
const pid_t exited = waitpid (child, &status, 0);
if (child != exited)
{
printf ("unexpected child: %d, expected %d\n", exited, child);
_exit_with_flush (4);
}
if (status != 0)
{
if (WIFEXITED (status))
printf ("unexpected exit status %d from child %d\n",
WEXITSTATUS (status), child);
else if (WIFSIGNALED (status))
printf ("unexpected signal %d from child %d\n",
WTERMSIG (status), child);
else
printf ("unexpected status %d from child %d\n", status, child);
_exit_with_flush (5);
}
}
break;
}
EXIT (2); /* If we see this exit code, fn_final must have not worked. */
}
#define TEST_FUNCTION do_test
#include <support/test-driver.c>
|
