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
145
146
147
148
149
150
151
152
153
154
155
156
|
/* Verify that DSO is unloaded only if its TLS objects are destroyed.
Copyright (C) 2013-2017 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/>. */
/* For the default case, i.e. NO_DELETE not defined, the test dynamically loads
a DSO and spawns a thread that subsequently calls into the DSO to register a
destructor for an object in the DSO and then calls dlclose on the handle for
the DSO. When the thread exits, the DSO should not be unloaded or else the
destructor called during thread exit will crash. Further in the main
thread, the DSO is opened and closed again, at which point the DSO should be
unloaded.
When NO_DELETE is defined, the DSO is loaded twice, once with just RTLD_LAZY
flag and the second time with the RTLD_NODELETE flag set. The thread is
spawned, destructor registered and then thread exits without closing the
DSO. In the main thread, the first handle is then closed, followed by the
second handle. In the end, the DSO should remain loaded due to the
RTLD_NODELETE flag being set in the second dlopen call. */
#include <dlfcn.h>
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <link.h>
#include <stdbool.h>
#ifndef NO_DELETE
# define LOADED_IS_GOOD false
#endif
#ifndef H2_RTLD_FLAGS
# define H2_RTLD_FLAGS (RTLD_LAZY)
#endif
#define DSO_NAME "$ORIGIN/tst-tls-atexit-lib.so"
/* Walk through the map in the _r_debug structure to see if our lib is still
loaded. */
static bool
is_loaded (void)
{
struct link_map *lm = (struct link_map *) _r_debug.r_map;
for (; lm; lm = lm->l_next)
if (lm->l_type == lt_loaded && lm->l_name
&& strcmp (basename (DSO_NAME), basename (lm->l_name)) == 0)
{
printf ("%s is still loaded\n", lm->l_name);
return true;
}
return false;
}
/* Accept a valid handle returned by DLOPEN, load the reg_dtor symbol to
register a destructor and then call dlclose on the handle. The dlclose
should not unload the DSO since the destructor has not been called yet. */
static void *
reg_dtor_and_close (void *h)
{
void (*reg_dtor) (void) = (void (*) (void)) dlsym (h, "reg_dtor");
if (reg_dtor == NULL)
{
printf ("Unable to find symbol: %s\n", dlerror ());
return (void *) (uintptr_t) 1;
}
reg_dtor ();
#ifndef NO_DELETE
dlclose (h);
#endif
return NULL;
}
static int
spawn_thread (void *h)
{
pthread_t t;
int ret;
void *thr_ret;
if ((ret = pthread_create (&t, NULL, reg_dtor_and_close, h)) != 0)
{
printf ("pthread_create failed: %s\n", strerror (ret));
return 1;
}
if ((ret = pthread_join (t, &thr_ret)) != 0)
{
printf ("pthread_join failed: %s\n", strerror (ret));
return 1;
}
if (thr_ret != NULL)
return 1;
return 0;
}
static int
do_test (void)
{
/* Load the DSO. */
void *h1 = dlopen (DSO_NAME, RTLD_LAZY);
if (h1 == NULL)
{
printf ("h1: Unable to load DSO: %s\n", dlerror ());
return 1;
}
#ifndef NO_DELETE
if (spawn_thread (h1) != 0)
return 1;
#endif
void *h2 = dlopen (DSO_NAME, H2_RTLD_FLAGS);
if (h2 == NULL)
{
printf ("h2: Unable to load DSO: %s\n", dlerror ());
return 1;
}
#ifdef NO_DELETE
if (spawn_thread (h1) != 0)
return 1;
dlclose (h1);
#endif
dlclose (h2);
/* Check link maps to ensure that the DSO has unloaded. In the normal case,
the DSO should be unloaded if there are no uses. However, if one of the
dlopen calls were with RTLD_NODELETE, the DSO should remain loaded. */
return is_loaded () == LOADED_IS_GOOD ? 0 : 1;
}
#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"
|
