1/* Call the termination functions of loaded shared objects.
2 Copyright (C) 1995-2016 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <assert.h>
20#include <string.h>
21#include <ldsodefs.h>
22
23
24/* Type of the constructor functions. */
25typedef void (*fini_t) (void);
26
27
28void
29internal_function
30_dl_sort_fini (struct link_map **maps, size_t nmaps, char *used, Lmid_t ns)
31{
32 /* A list of one element need not be sorted. */
33 if (nmaps == 1)
34 return;
35
36 /* We can skip looking for the binary itself which is at the front
37 of the search list for the main namespace. */
38 unsigned int i = ns == LM_ID_BASE;
39 uint16_t seen[nmaps];
40 memset (seen, 0, nmaps * sizeof (seen[0]));
41 while (1)
42 {
43 /* Keep track of which object we looked at this round. */
44 ++seen[i];
45 struct link_map *thisp = maps[i];
46
47 /* Do not handle ld.so in secondary namespaces and object which
48 are not removed. */
49 if (thisp != thisp->l_real || thisp->l_idx == -1)
50 goto skip;
51
52 /* Find the last object in the list for which the current one is
53 a dependency and move the current object behind the object
54 with the dependency. */
55 unsigned int k = nmaps - 1;
56 while (k > i)
57 {
58 struct link_map **runp = maps[k]->l_initfini;
59 if (runp != NULL)
60 /* Look through the dependencies of the object. */
61 while (*runp != NULL)
62 if (__glibc_unlikely (*runp++ == thisp))
63 {
64 move:
65 /* Move the current object to the back past the last
66 object with it as the dependency. */
67 memmove (&maps[i], &maps[i + 1],
68 (k - i) * sizeof (maps[0]));
69 maps[k] = thisp;
70
71 if (used != NULL)
72 {
73 char here_used = used[i];
74 memmove (&used[i], &used[i + 1],
75 (k - i) * sizeof (used[0]));
76 used[k] = here_used;
77 }
78
79 if (seen[i + 1] > nmaps - i)
80 {
81 ++i;
82 goto next_clear;
83 }
84
85 uint16_t this_seen = seen[i];
86 memmove (&seen[i], &seen[i + 1], (k - i) * sizeof (seen[0]));
87 seen[k] = this_seen;
88
89 goto next;
90 }
91
92 if (__glibc_unlikely (maps[k]->l_reldeps != NULL))
93 {
94 unsigned int m = maps[k]->l_reldeps->act;
95 struct link_map **relmaps = &maps[k]->l_reldeps->list[0];
96
97 /* Look through the relocation dependencies of the object. */
98 while (m-- > 0)
99 if (__glibc_unlikely (relmaps[m] == thisp))
100 {
101 /* If a cycle exists with a link time dependency,
102 preserve the latter. */
103 struct link_map **runp = thisp->l_initfini;
104 if (runp != NULL)
105 while (*runp != NULL)
106 if (__glibc_unlikely (*runp++ == maps[k]))
107 goto ignore;
108 goto move;
109 }
110 ignore:;
111 }
112
113 --k;
114 }
115
116 skip:
117 if (++i == nmaps)
118 break;
119 next_clear:
120 memset (&seen[i], 0, (nmaps - i) * sizeof (seen[0]));
121
122 next:;
123 }
124}
125
126
127void
128internal_function
129_dl_fini (void)
130{
131 /* Lots of fun ahead. We have to call the destructors for all still
132 loaded objects, in all namespaces. The problem is that the ELF
133 specification now demands that dependencies between the modules
134 are taken into account. I.e., the destructor for a module is
135 called before the ones for any of its dependencies.
136
137 To make things more complicated, we cannot simply use the reverse
138 order of the constructors. Since the user might have loaded objects
139 using `dlopen' there are possibly several other modules with its
140 dependencies to be taken into account. Therefore we have to start
141 determining the order of the modules once again from the beginning. */
142
143 /* We run the destructors of the main namespaces last. As for the
144 other namespaces, we pick run the destructors in them in reverse
145 order of the namespace ID. */
146#ifdef SHARED
147 int do_audit = 0;
148 again:
149#endif
150 for (Lmid_t ns = GL(dl_nns) - 1; ns >= 0; --ns)
151 {
152 /* Protect against concurrent loads and unloads. */
153 __rtld_lock_lock_recursive (GL(dl_load_lock));
154
155 unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
156 /* No need to do anything for empty namespaces or those used for
157 auditing DSOs. */
158 if (nloaded == 0
159#ifdef SHARED
160 || GL(dl_ns)[ns]._ns_loaded->l_auditing != do_audit
161#endif
162 )
163 __rtld_lock_unlock_recursive (GL(dl_load_lock));
164 else
165 {
166 /* Now we can allocate an array to hold all the pointers and
167 copy the pointers in. */
168 struct link_map *maps[nloaded];
169
170 unsigned int i;
171 struct link_map *l;
172 assert (nloaded != 0 || GL(dl_ns)[ns]._ns_loaded == NULL);
173 for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next)
174 /* Do not handle ld.so in secondary namespaces. */
175 if (l == l->l_real)
176 {
177 assert (i < nloaded);
178
179 maps[i] = l;
180 l->l_idx = i;
181 ++i;
182
183 /* Bump l_direct_opencount of all objects so that they
184 are not dlclose()ed from underneath us. */
185 ++l->l_direct_opencount;
186 }
187 assert (ns != LM_ID_BASE || i == nloaded);
188 assert (ns == LM_ID_BASE || i == nloaded || i == nloaded - 1);
189 unsigned int nmaps = i;
190
191 /* Now we have to do the sorting. */
192 _dl_sort_fini (maps, nmaps, NULL, ns);
193
194 /* We do not rely on the linked list of loaded object anymore
195 from this point on. We have our own list here (maps). The
196 various members of this list cannot vanish since the open
197 count is too high and will be decremented in this loop. So
198 we release the lock so that some code which might be called
199 from a destructor can directly or indirectly access the
200 lock. */
201 __rtld_lock_unlock_recursive (GL(dl_load_lock));
202
203 /* 'maps' now contains the objects in the right order. Now
204 call the destructors. We have to process this array from
205 the front. */
206 for (i = 0; i < nmaps; ++i)
207 {
208 struct link_map *l = maps[i];
209
210 if (l->l_init_called)
211 {
212 /* Make sure nothing happens if we are called twice. */
213 l->l_init_called = 0;
214
215 /* Is there a destructor function? */
216 if (l->l_info[DT_FINI_ARRAY] != NULL
217 || l->l_info[DT_FINI] != NULL)
218 {
219 /* When debugging print a message first. */
220 if (__builtin_expect (GLRO(dl_debug_mask)
221 & DL_DEBUG_IMPCALLS, 0))
222 _dl_debug_printf ("\ncalling fini: %s [%lu]\n\n",
223 DSO_FILENAME (l->l_name),
224 ns);
225
226 /* First see whether an array is given. */
227 if (l->l_info[DT_FINI_ARRAY] != NULL)
228 {
229 ElfW(Addr) *array =
230 (ElfW(Addr) *) (l->l_addr
231 + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
232 unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
233 / sizeof (ElfW(Addr)));
234 while (i-- > 0)
235 ((fini_t) array[i]) ();
236 }
237
238 /* Next try the old-style destructor. */
239 if (l->l_info[DT_FINI] != NULL)
240 DL_CALL_DT_FINI
241 (l, l->l_addr + l->l_info[DT_FINI]->d_un.d_ptr);
242 }
243
244#ifdef SHARED
245 /* Auditing checkpoint: another object closed. */
246 if (!do_audit && __builtin_expect (GLRO(dl_naudit) > 0, 0))
247 {
248 struct audit_ifaces *afct = GLRO(dl_audit);
249 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
250 {
251 if (afct->objclose != NULL)
252 /* Return value is ignored. */
253 (void) afct->objclose (&l->l_audit[cnt].cookie);
254
255 afct = afct->next;
256 }
257 }
258#endif
259 }
260
261 /* Correct the previous increment. */
262 --l->l_direct_opencount;
263 }
264 }
265 }
266
267#ifdef SHARED
268 if (! do_audit && GLRO(dl_naudit) > 0)
269 {
270 do_audit = 1;
271 goto again;
272 }
273
274 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
275 _dl_debug_printf ("\nruntime linker statistics:\n"
276 " final number of relocations: %lu\n"
277 "final number of relocations from cache: %lu\n",
278 GL(dl_num_relocations),
279 GL(dl_num_cache_relocations));
280#endif
281}
282