1 /* Close a shared object opened by `_dl_open'.
2 Copyright (C) 1996-2001, 2002 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26 #include <bits/libc-lock.h>
28 #include <sys/types.h>
32 /* Type of the constructor functions. */
33 typedef void (*fini_t
) (void);
37 /* Returns true we an non-empty was found. */
39 remove_slotinfo (size_t idx
, struct dtv_slotinfo_list
*listp
, size_t disp
)
41 if (idx
- disp
>= listp
->len
)
43 /* There must be a next entry. Otherwise would the index be wrong. */
44 assert (listp
->next
!= NULL
);
46 if (remove_slotinfo (idx
, listp
->next
, disp
+ listp
->len
))
49 /* No non-empty entry. Search from the end of this elements
51 idx
= disp
+ listp
->len
;
55 struct link_map
*old_map
= listp
->slotinfo
[idx
- disp
].map
;
56 assert (old_map
!= NULL
);
58 /* Mark the entry as unused. */
59 listp
->slotinfo
[idx
- disp
].gen
= GL(dl_tls_generation
) + 1;
60 listp
->slotinfo
[idx
- disp
].map
= NULL
;
62 /* If this is not the last currently used entry no need to look
64 if (old_map
->l_tls_modid
!= GL(dl_tls_max_dtv_idx
))
67 assert (old_map
->l_tls_modid
== GL(dl_tls_max_dtv_idx
));
70 while (idx
- disp
> disp
== 0 ? 1 + GL(dl_tls_static_nelem
) : 0)
74 if (listp
->slotinfo
[idx
- disp
].map
!= NULL
)
76 /* Found a new last used index. */
77 GL(dl_tls_max_dtv_idx
) = idx
;
82 /* No non-entry in this list element. */
90 _dl_close (void *_map
)
94 struct link_map
**rellist
;
95 unsigned int nrellist
;
96 struct reldep_list
*next
;
98 struct link_map
**list
;
99 struct link_map
*map
= _map
;
101 unsigned int *new_opencount
;
103 bool any_tls
= false;
106 /* First see whether we can remove the object at all. */
107 if (__builtin_expect (map
->l_flags_1
& DF_1_NODELETE
, 0)
108 && map
->l_init_called
)
109 /* Nope. Do nothing. */
112 if (__builtin_expect (map
->l_opencount
, 1) == 0)
113 _dl_signal_error (0, map
->l_name
, NULL
, N_("shared object not open"));
115 /* Acquire the lock. */
116 __libc_lock_lock_recursive (GL(dl_load_lock
));
118 /* Decrement the reference count. */
119 if (map
->l_opencount
> 1 || map
->l_type
!= lt_loaded
)
121 /* There are still references to this object. Do nothing more. */
122 if (__builtin_expect (GL(dl_debug_mask
) & DL_DEBUG_FILES
, 0))
123 _dl_debug_printf ("\nclosing file=%s; opencount == %u\n",
124 map
->l_name
, map
->l_opencount
);
126 /* One decrement the object itself, not the dependencies. */
129 __libc_lock_unlock_recursive (GL(dl_load_lock
));
133 list
= map
->l_initfini
;
135 /* Compute the new l_opencount values. */
136 i
= map
->l_searchlist
.r_nlist
;
137 if (__builtin_expect (i
== 0, 0))
138 /* This can happen if we handle relocation dependencies for an
139 object which wasn't loaded directly. */
140 for (i
= 1; list
[i
] != NULL
; ++i
)
143 new_opencount
= (unsigned int *) alloca (i
* sizeof (unsigned int));
145 for (i
= 0; list
[i
] != NULL
; ++i
)
148 new_opencount
[i
] = list
[i
]->l_opencount
;
151 for (i
= 1; list
[i
] != NULL
; ++i
)
152 if ((! (list
[i
]->l_flags_1
& DF_1_NODELETE
) || ! list
[i
]->l_init_called
)
153 /* Decrement counter. */
154 && --new_opencount
[i
] == 0
155 /* Test whether this object was also loaded directly. */
156 && list
[i
]->l_searchlist
.r_list
!= NULL
)
158 /* In this case we have the decrement all the dependencies of
159 this object. They are all in MAP's dependency list. */
161 struct link_map
**dep_list
= list
[i
]->l_searchlist
.r_list
;
163 for (j
= 1; j
< list
[i
]->l_searchlist
.r_nlist
; ++j
)
164 if (! (dep_list
[j
]->l_flags_1
& DF_1_NODELETE
)
165 || ! dep_list
[j
]->l_init_called
)
167 assert (dep_list
[j
]->l_idx
< map
->l_searchlist
.r_nlist
);
168 --new_opencount
[dep_list
[j
]->l_idx
];
171 assert (new_opencount
[0] == 0);
173 /* Call all termination functions at once. */
174 for (i
= 0; list
[i
] != NULL
; ++i
)
176 struct link_map
*imap
= list
[i
];
177 if (new_opencount
[i
] == 0 && imap
->l_type
== lt_loaded
178 && (imap
->l_info
[DT_FINI
] || imap
->l_info
[DT_FINI_ARRAY
])
179 && (! (imap
->l_flags_1
& DF_1_NODELETE
) || ! imap
->l_init_called
)
180 /* Skip any half-cooked objects that were never initialized. */
181 && imap
->l_init_called
)
183 /* When debugging print a message first. */
184 if (__builtin_expect (GL(dl_debug_mask
) & DL_DEBUG_IMPCALLS
, 0))
185 _dl_debug_printf ("\ncalling fini: %s\n\n", imap
->l_name
);
187 /* Call its termination function. */
188 if (imap
->l_info
[DT_FINI_ARRAY
] != NULL
)
191 (ElfW(Addr
) *) (imap
->l_addr
192 + imap
->l_info
[DT_FINI_ARRAY
]->d_un
.d_ptr
);
193 unsigned int sz
= (imap
->l_info
[DT_FINI_ARRAYSZ
]->d_un
.d_val
194 / sizeof (ElfW(Addr
)));
197 for (cnt
= 0; cnt
< sz
; ++cnt
)
198 ((fini_t
) (imap
->l_addr
+ array
[cnt
])) ();
201 /* Next try the old-style destructor. */
202 if (imap
->l_info
[DT_FINI
] != NULL
)
203 (*(void (*) (void)) DL_DT_FINI_ADDRESS
204 (imap
, (void *) imap
->l_addr
205 + imap
->l_info
[DT_FINI
]->d_un
.d_ptr
)) ();
207 else if (new_opencount
[i
] != 0 && imap
->l_type
== lt_loaded
)
209 /* The object is still used. But the object we are unloading
210 right now is responsible for loading it and therefore we
211 have the search list of the current object in its scope.
213 struct r_scope_elem
**runp
= imap
->l_scope
;
215 while (*runp
!= NULL
)
216 if (*runp
== &map
->l_searchlist
)
218 /* Copy all later elements. */
219 while ((runp
[0] = runp
[1]) != NULL
)
227 /* Store the new l_opencount value. */
228 imap
->l_opencount
= new_opencount
[i
];
229 /* Just a sanity check. */
230 assert (imap
->l_type
== lt_loaded
|| imap
->l_opencount
> 0);
233 /* Notify the debugger we are about to remove some loaded objects. */
234 _r_debug
.r_state
= RT_DELETE
;
237 /* Check each element of the search list to see if all references to
239 for (i
= 0; list
[i
] != NULL
; ++i
)
241 struct link_map
*imap
= list
[i
];
242 if (imap
->l_opencount
== 0 && imap
->l_type
== lt_loaded
)
244 struct libname_list
*lnp
;
246 /* That was the last reference, and this was a dlopen-loaded
247 object. We can unmap it. */
248 if (__builtin_expect (imap
->l_global
, 0))
250 /* This object is in the global scope list. Remove it. */
251 unsigned int cnt
= GL(dl_main_searchlist
)->r_nlist
;
255 while (GL(dl_main_searchlist
)->r_list
[cnt
] != imap
);
257 /* The object was already correctly registered. */
258 while (++cnt
< GL(dl_main_searchlist
)->r_nlist
)
259 GL(dl_main_searchlist
)->r_list
[cnt
- 1]
260 = GL(dl_main_searchlist
)->r_list
[cnt
];
262 --GL(dl_main_searchlist
)->r_nlist
;
266 /* Remove the object from the dtv slotinfo array if it uses
268 if (__builtin_expect (imap
->l_tls_blocksize
> 0, 0))
272 if (! remove_slotinfo (imap
->l_tls_modid
,
273 GL(dl_tls_dtv_slotinfo_list
), 0))
274 /* All dynamically loaded modules with TLS are unloaded. */
275 GL(dl_tls_max_dtv_idx
) = GL(dl_tls_static_nelem
);
279 /* We can unmap all the maps at once. We determined the
280 start address and length when we loaded the object and
281 the `munmap' call does the rest. */
284 /* Finally, unlink the data structure and free it. */
286 /* We will unlink the first object only if this is a statically
288 assert (imap
->l_prev
!= NULL
);
289 imap
->l_prev
->l_next
= imap
->l_next
;
291 if (imap
->l_prev
!= NULL
)
292 imap
->l_prev
->l_next
= imap
->l_next
;
294 GL(dl_loaded
) = imap
->l_next
;
298 imap
->l_next
->l_prev
= imap
->l_prev
;
300 if (imap
->l_versions
!= NULL
)
301 free (imap
->l_versions
);
302 if (imap
->l_origin
!= NULL
&& imap
->l_origin
!= (char *) -1)
303 free ((char *) imap
->l_origin
);
305 /* If the object has relocation dependencies save this
306 information for latter. */
307 if (__builtin_expect (imap
->l_reldeps
!= NULL
, 0))
309 struct reldep_list
*newrel
;
311 newrel
= (struct reldep_list
*) alloca (sizeof (*reldeps
));
312 newrel
->rellist
= imap
->l_reldeps
;
313 newrel
->nrellist
= imap
->l_reldepsact
;
314 newrel
->next
= reldeps
;
319 /* This name always is allocated. */
321 /* Remove the list with all the names of the shared object. */
322 lnp
= imap
->l_libname
;
325 struct libname_list
*this = lnp
;
327 if (!this->dont_free
)
332 /* Remove the searchlists. */
334 free (imap
->l_initfini
);
336 /* Remove the scope array if we allocated it. */
337 if (imap
->l_scope
!= imap
->l_scope_mem
)
338 free (imap
->l_scope
);
340 if (imap
->l_phdr_allocated
)
341 free ((void *) imap
->l_phdr
);
343 if (imap
->l_rpath_dirs
.dirs
!= (void *) -1)
344 free (imap
->l_rpath_dirs
.dirs
);
345 if (imap
->l_runpath_dirs
.dirs
!= (void *) -1)
346 free (imap
->l_runpath_dirs
.dirs
);
353 /* If we removed any object which uses TLS bumnp the generation
356 if (__builtin_expect (++GL(dl_tls_generation
) == 0, 0))
357 __libc_fatal (_("TLS generation counter wrapped! Please send report with the 'glibcbug' script."));
360 /* Notify the debugger those objects are finalized and gone. */
361 _r_debug
.r_state
= RT_CONSISTENT
;
364 /* Now we can perhaps also remove the modules for which we had
365 dependencies because of symbol lookup. */
366 while (__builtin_expect (reldeps
!= NULL
, 0))
368 while (reldeps
->nrellist
-- > 0)
369 _dl_close (reldeps
->rellist
[reldeps
->nrellist
]);
371 free (reldeps
->rellist
);
373 reldeps
= reldeps
->next
;
378 /* Release the lock. */
379 __libc_lock_unlock_recursive (GL(dl_load_lock
));
381 libc_hidden_def (_dl_close
)
386 free_slotinfo (struct dtv_slotinfo_list
*elemp
)
391 /* Nothing here, all is removed (or there never was anything). */
394 if (!free_slotinfo (elemp
->next
))
395 /* We cannot free the entry. */
398 /* The least we could do is remove next element (if there was any). */
401 for (cnt
= 0; cnt
< elemp
->len
; ++cnt
)
402 if (elemp
->slotinfo
[cnt
].map
!= NULL
)
406 /* We can remove the list element. */
417 if (__builtin_expect (GL(dl_global_scope_alloc
), 0) != 0
418 && GL(dl_main_searchlist
)->r_nlist
== GL(dl_initial_searchlist
).r_nlist
)
420 /* All object dynamically loaded by the program are unloaded. Free
421 the memory allocated for the global scope variable. */
422 struct link_map
**old
= GL(dl_main_searchlist
)->r_list
;
424 /* Put the old map in. */
425 GL(dl_main_searchlist
)->r_list
= GL(dl_initial_searchlist
).r_list
;
426 /* Signal that the original map is used. */
427 GL(dl_global_scope_alloc
) = 0;
429 /* Now free the old map. */
434 /* Free the memory allocated for the dtv slotinfo array. We can do
435 this only if all modules which used this memory are unloaded.
436 Also, the first element of the list does not have to be
437 deallocated. It was allocated in the dynamic linker (i.e., with
438 a different malloc). */
439 if (free_slotinfo (GL(dl_tls_dtv_slotinfo_list
)->next
))
440 GL(dl_tls_dtv_slotinfo_list
)->next
= NULL
;
443 text_set_element (__libc_subfreeres
, free_mem
);