1 /* Close a shared object opened by `_dl_open'.
2 Copyright (C) 1996-2019 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, see
17 <https://www.gnu.org/licenses/>. */
28 #include <libc-lock.h>
30 #include <sys/types.h>
32 #include <sysdep-cancel.h>
34 #include <stap-probe.h>
36 #include <dl-unmap-segments.h>
39 /* Type of the constructor functions. */
40 typedef void (*fini_t
) (void);
43 /* Special l_idx value used to indicate which objects remain loaded. */
44 #define IDX_STILL_USED -1
47 /* Returns true we an non-empty was found. */
49 remove_slotinfo (size_t idx
, struct dtv_slotinfo_list
*listp
, size_t disp
,
52 if (idx
- disp
>= listp
->len
)
54 if (listp
->next
== NULL
)
56 /* The index is not actually valid in the slotinfo list,
57 because this object was closed before it was fully set
58 up due to some error. */
59 assert (! should_be_there
);
63 if (remove_slotinfo (idx
, listp
->next
, disp
+ listp
->len
,
67 /* No non-empty entry. Search from the end of this element's
69 idx
= disp
+ listp
->len
;
74 struct link_map
*old_map
= listp
->slotinfo
[idx
- disp
].map
;
76 /* The entry might still be in its unused state if we are closing an
77 object that wasn't fully set up. */
78 if (__glibc_likely (old_map
!= NULL
))
80 assert (old_map
->l_tls_modid
== idx
);
82 /* Mark the entry as unused. */
83 listp
->slotinfo
[idx
- disp
].gen
= GL(dl_tls_generation
) + 1;
84 listp
->slotinfo
[idx
- disp
].map
= NULL
;
87 /* If this is not the last currently used entry no need to look
89 if (idx
!= GL(dl_tls_max_dtv_idx
))
93 while (idx
- disp
> (disp
== 0 ? 1 + GL(dl_tls_static_nelem
) : 0))
97 if (listp
->slotinfo
[idx
- disp
].map
!= NULL
)
99 /* Found a new last used index. */
100 GL(dl_tls_max_dtv_idx
) = idx
;
105 /* No non-entry in this list element. */
111 _dl_close_worker (struct link_map
*map
, bool force
)
113 /* One less direct use. */
114 --map
->l_direct_opencount
;
116 /* If _dl_close is called recursively (some destructor call dlclose),
117 just record that the parent _dl_close will need to do garbage collection
119 static enum { not_pending
, pending
, rerun
} dl_close_state
;
121 if (map
->l_direct_opencount
> 0 || map
->l_type
!= lt_loaded
122 || dl_close_state
!= not_pending
)
124 if (map
->l_direct_opencount
== 0 && map
->l_type
== lt_loaded
)
125 dl_close_state
= rerun
;
127 /* There are still references to this object. Do nothing more. */
128 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
))
129 _dl_debug_printf ("\nclosing file=%s; direct_opencount=%u\n",
130 map
->l_name
, map
->l_direct_opencount
);
135 Lmid_t nsid
= map
->l_ns
;
136 struct link_namespaces
*ns
= &GL(dl_ns
)[nsid
];
139 dl_close_state
= pending
;
141 bool any_tls
= false;
142 const unsigned int nloaded
= ns
->_ns_nloaded
;
145 struct link_map
*maps
[nloaded
];
147 /* Clear DF_1_NODELETE to force object deletion. We don't need to touch
148 l_tls_dtor_count because forced object deletion only happens when an
149 error occurs during object load. Destructor registration for TLS
150 non-POD objects should not have happened till then for this
153 map
->l_flags_1
&= ~DF_1_NODELETE
;
155 /* Run over the list and assign indexes to the link maps and enter
156 them into the MAPS array. */
158 for (struct link_map
*l
= ns
->_ns_loaded
; l
!= NULL
; l
= l
->l_next
)
165 assert (idx
== nloaded
);
167 /* Prepare the bitmaps. */
168 memset (used
, '\0', sizeof (used
));
169 memset (done
, '\0', sizeof (done
));
171 /* Keep track of the lowest index link map we have covered already. */
173 while (++done_index
< nloaded
)
175 struct link_map
*l
= maps
[done_index
];
177 if (done
[done_index
])
178 /* Already handled. */
181 /* Check whether this object is still used. */
182 if (l
->l_type
== lt_loaded
183 && l
->l_direct_opencount
== 0
184 && (l
->l_flags_1
& DF_1_NODELETE
) == 0
185 /* See CONCURRENCY NOTES in cxa_thread_atexit_impl.c to know why
186 acquire is sufficient and correct. */
187 && atomic_load_acquire (&l
->l_tls_dtor_count
) == 0
188 && !used
[done_index
])
191 /* We need this object and we handle it now. */
192 done
[done_index
] = 1;
193 used
[done_index
] = 1;
194 /* Signal the object is still needed. */
195 l
->l_idx
= IDX_STILL_USED
;
197 /* Mark all dependencies as used. */
198 if (l
->l_initfini
!= NULL
)
200 /* We are always the zeroth entry, and since we don't include
201 ourselves in the dependency analysis start at 1. */
202 struct link_map
**lp
= &l
->l_initfini
[1];
205 if ((*lp
)->l_idx
!= IDX_STILL_USED
)
207 assert ((*lp
)->l_idx
>= 0 && (*lp
)->l_idx
< nloaded
);
209 if (!used
[(*lp
)->l_idx
])
211 used
[(*lp
)->l_idx
] = 1;
212 /* If we marked a new object as used, and we've
213 already processed it, then we need to go back
214 and process again from that point forward to
215 ensure we keep all of its dependencies also. */
216 if ((*lp
)->l_idx
- 1 < done_index
)
217 done_index
= (*lp
)->l_idx
- 1;
224 /* And the same for relocation dependencies. */
225 if (l
->l_reldeps
!= NULL
)
226 for (unsigned int j
= 0; j
< l
->l_reldeps
->act
; ++j
)
228 struct link_map
*jmap
= l
->l_reldeps
->list
[j
];
230 if (jmap
->l_idx
!= IDX_STILL_USED
)
232 assert (jmap
->l_idx
>= 0 && jmap
->l_idx
< nloaded
);
234 if (!used
[jmap
->l_idx
])
236 used
[jmap
->l_idx
] = 1;
237 if (jmap
->l_idx
- 1 < done_index
)
238 done_index
= jmap
->l_idx
- 1;
244 /* Sort the entries. We can skip looking for the binary itself which is
245 at the front of the search list for the main namespace. */
246 _dl_sort_maps (maps
+ (nsid
== LM_ID_BASE
), nloaded
- (nsid
== LM_ID_BASE
),
247 used
+ (nsid
== LM_ID_BASE
), true);
249 /* Call all termination functions at once. */
251 bool do_audit
= GLRO(dl_naudit
) > 0 && !ns
->_ns_loaded
->l_auditing
;
253 bool unload_any
= false;
254 bool scope_mem_left
= false;
255 unsigned int unload_global
= 0;
256 unsigned int first_loaded
= ~0;
257 for (unsigned int i
= 0; i
< nloaded
; ++i
)
259 struct link_map
*imap
= maps
[i
];
261 /* All elements must be in the same namespace. */
262 assert (imap
->l_ns
== nsid
);
266 assert (imap
->l_type
== lt_loaded
267 && (imap
->l_flags_1
& DF_1_NODELETE
) == 0);
269 /* Call its termination function. Do not do it for
270 half-cooked objects. */
271 if (imap
->l_init_called
)
273 /* When debugging print a message first. */
274 if (__builtin_expect (GLRO(dl_debug_mask
) & DL_DEBUG_IMPCALLS
,
276 _dl_debug_printf ("\ncalling fini: %s [%lu]\n\n",
279 if (imap
->l_info
[DT_FINI_ARRAY
] != NULL
)
282 (ElfW(Addr
) *) (imap
->l_addr
283 + imap
->l_info
[DT_FINI_ARRAY
]->d_un
.d_ptr
);
284 unsigned int sz
= (imap
->l_info
[DT_FINI_ARRAYSZ
]->d_un
.d_val
285 / sizeof (ElfW(Addr
)));
288 ((fini_t
) array
[sz
]) ();
291 /* Next try the old-style destructor. */
292 if (imap
->l_info
[DT_FINI
] != NULL
)
293 DL_CALL_DT_FINI (imap
, ((void *) imap
->l_addr
294 + imap
->l_info
[DT_FINI
]->d_un
.d_ptr
));
298 /* Auditing checkpoint: we remove an object. */
299 if (__glibc_unlikely (do_audit
))
301 struct audit_ifaces
*afct
= GLRO(dl_audit
);
302 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
304 if (afct
->objclose
!= NULL
)
306 struct auditstate
*state
307 = link_map_audit_state (imap
, cnt
);
308 /* Return value is ignored. */
309 (void) afct
->objclose (&state
->cookie
);
317 /* This object must not be used anymore. */
320 /* We indeed have an object to remove. */
326 /* Remember where the first dynamically loaded object is. */
327 if (i
< first_loaded
)
331 else if (imap
->l_type
== lt_loaded
)
333 struct r_scope_elem
*new_list
= NULL
;
335 if (imap
->l_searchlist
.r_list
== NULL
&& imap
->l_initfini
!= NULL
)
337 /* The object is still used. But one of the objects we are
338 unloading right now is responsible for loading it. If
339 the current object does not have it's own scope yet we
340 have to create one. This has to be done before running
343 To do this count the number of dependencies. */
345 for (cnt
= 1; imap
->l_initfini
[cnt
] != NULL
; ++cnt
)
348 /* We simply reuse the l_initfini list. */
349 imap
->l_searchlist
.r_list
= &imap
->l_initfini
[cnt
+ 1];
350 imap
->l_searchlist
.r_nlist
= cnt
;
352 new_list
= &imap
->l_searchlist
;
355 /* Count the number of scopes which remain after the unload.
356 When we add the local search list count it. Always add
357 one for the terminating NULL pointer. */
358 size_t remain
= (new_list
!= NULL
) + 1;
359 bool removed_any
= false;
360 for (size_t cnt
= 0; imap
->l_scope
[cnt
] != NULL
; ++cnt
)
361 /* This relies on l_scope[] entries being always set either
362 to its own l_symbolic_searchlist address, or some map's
363 l_searchlist address. */
364 if (imap
->l_scope
[cnt
] != &imap
->l_symbolic_searchlist
)
366 struct link_map
*tmap
= (struct link_map
*)
367 ((char *) imap
->l_scope
[cnt
]
368 - offsetof (struct link_map
, l_searchlist
));
369 assert (tmap
->l_ns
== nsid
);
370 if (tmap
->l_idx
== IDX_STILL_USED
)
380 /* Always allocate a new array for the scope. This is
381 necessary since we must be able to determine the last
382 user of the current array. If possible use the link map's
385 struct r_scope_elem
**newp
;
387 #define SCOPE_ELEMS(imap) \
388 (sizeof (imap->l_scope_mem) / sizeof (imap->l_scope_mem[0]))
390 if (imap
->l_scope
!= imap
->l_scope_mem
391 && remain
< SCOPE_ELEMS (imap
))
393 new_size
= SCOPE_ELEMS (imap
);
394 newp
= imap
->l_scope_mem
;
398 new_size
= imap
->l_scope_max
;
399 newp
= (struct r_scope_elem
**)
400 malloc (new_size
* sizeof (struct r_scope_elem
*));
402 _dl_signal_error (ENOMEM
, "dlclose", NULL
,
403 N_("cannot create scope list"));
406 /* Copy over the remaining scope elements. */
408 for (size_t cnt
= 0; imap
->l_scope
[cnt
] != NULL
; ++cnt
)
410 if (imap
->l_scope
[cnt
] != &imap
->l_symbolic_searchlist
)
412 struct link_map
*tmap
= (struct link_map
*)
413 ((char *) imap
->l_scope
[cnt
]
414 - offsetof (struct link_map
, l_searchlist
));
415 if (tmap
->l_idx
!= IDX_STILL_USED
)
417 /* Remove the scope. Or replace with own map's
419 if (new_list
!= NULL
)
421 newp
[remain
++] = new_list
;
428 newp
[remain
++] = imap
->l_scope
[cnt
];
432 struct r_scope_elem
**old
= imap
->l_scope
;
434 imap
->l_scope
= newp
;
436 /* No user anymore, we can free it now. */
437 if (old
!= imap
->l_scope_mem
)
439 if (_dl_scope_free (old
))
440 /* If _dl_scope_free used THREAD_GSCOPE_WAIT (),
441 no need to repeat it. */
442 scope_mem_left
= false;
445 scope_mem_left
= true;
447 imap
->l_scope_max
= new_size
;
449 else if (new_list
!= NULL
)
451 /* We didn't change the scope array, so reset the search
453 imap
->l_searchlist
.r_list
= NULL
;
454 imap
->l_searchlist
.r_nlist
= 0;
457 /* The loader is gone, so mark the object as not having one.
458 Note: l_idx != IDX_STILL_USED -> object will be removed. */
459 if (imap
->l_loader
!= NULL
460 && imap
->l_loader
->l_idx
!= IDX_STILL_USED
)
461 imap
->l_loader
= NULL
;
463 /* Remember where the first dynamically loaded object is. */
464 if (i
< first_loaded
)
469 /* If there are no objects to unload, do nothing further. */
474 /* Auditing checkpoint: we will start deleting objects. */
475 if (__glibc_unlikely (do_audit
))
477 struct link_map
*head
= ns
->_ns_loaded
;
478 struct audit_ifaces
*afct
= GLRO(dl_audit
);
479 /* Do not call the functions for any auditing object. */
480 if (head
->l_auditing
== 0)
482 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
484 if (afct
->activity
!= NULL
)
486 struct auditstate
*state
= link_map_audit_state (head
, cnt
);
487 afct
->activity (&state
->cookie
, LA_ACT_DELETE
);
496 /* Notify the debugger we are about to remove some loaded objects. */
497 struct r_debug
*r
= _dl_debug_initialize (0, nsid
);
498 r
->r_state
= RT_DELETE
;
500 LIBC_PROBE (unmap_start
, 2, nsid
, r
);
504 /* Some objects are in the global scope list. Remove them. */
505 struct r_scope_elem
*ns_msl
= ns
->_ns_main_searchlist
;
508 unsigned int cnt
= ns_msl
->r_nlist
;
510 while (cnt
> 0 && ns_msl
->r_list
[cnt
- 1]->l_removed
)
513 if (cnt
+ unload_global
== ns_msl
->r_nlist
)
514 /* Speed up removing most recently added objects. */
517 for (i
= 0; i
< cnt
; i
++)
518 if (ns_msl
->r_list
[i
]->l_removed
== 0)
521 ns_msl
->r_list
[j
] = ns_msl
->r_list
[i
];
527 if (!RTLD_SINGLE_THREAD_P
530 || (GL(dl_scope_free_list
) != NULL
531 && GL(dl_scope_free_list
)->count
)))
533 THREAD_GSCOPE_WAIT ();
535 /* Now we can free any queued old scopes. */
536 struct dl_scope_free_list
*fsl
= GL(dl_scope_free_list
);
538 while (fsl
->count
> 0)
539 free (fsl
->list
[--fsl
->count
]);
542 size_t tls_free_start
;
544 tls_free_start
= tls_free_end
= NO_TLS_OFFSET
;
546 /* We modify the list of loaded objects. */
547 __rtld_lock_lock_recursive (GL(dl_load_write_lock
));
549 /* Check each element of the search list to see if all references to
551 for (unsigned int i
= first_loaded
; i
< nloaded
; ++i
)
553 struct link_map
*imap
= maps
[i
];
556 assert (imap
->l_type
== lt_loaded
);
558 /* That was the last reference, and this was a dlopen-loaded
559 object. We can unmap it. */
561 /* Remove the object from the dtv slotinfo array if it uses TLS. */
562 if (__glibc_unlikely (imap
->l_tls_blocksize
> 0))
566 if (GL(dl_tls_dtv_slotinfo_list
) != NULL
567 && ! remove_slotinfo (imap
->l_tls_modid
,
568 GL(dl_tls_dtv_slotinfo_list
), 0,
569 imap
->l_init_called
))
570 /* All dynamically loaded modules with TLS are unloaded. */
571 GL(dl_tls_max_dtv_idx
) = GL(dl_tls_static_nelem
);
573 if (imap
->l_tls_offset
!= NO_TLS_OFFSET
574 && imap
->l_tls_offset
!= FORCED_DYNAMIC_TLS_OFFSET
)
576 /* Collect a contiguous chunk built from the objects in
577 this search list, going in either direction. When the
578 whole chunk is at the end of the used area then we can
581 if (tls_free_start
== NO_TLS_OFFSET
582 || (size_t) imap
->l_tls_offset
== tls_free_start
)
584 /* Extend the contiguous chunk being reclaimed. */
586 = imap
->l_tls_offset
- imap
->l_tls_blocksize
;
588 if (tls_free_end
== NO_TLS_OFFSET
)
589 tls_free_end
= imap
->l_tls_offset
;
591 else if (imap
->l_tls_offset
- imap
->l_tls_blocksize
593 /* Extend the chunk backwards. */
594 tls_free_end
= imap
->l_tls_offset
;
597 /* This isn't contiguous with the last chunk freed.
598 One of them will be leaked unless we can free
599 one block right away. */
600 if (tls_free_end
== GL(dl_tls_static_used
))
602 GL(dl_tls_static_used
) = tls_free_start
;
603 tls_free_end
= imap
->l_tls_offset
;
605 = tls_free_end
- imap
->l_tls_blocksize
;
607 else if ((size_t) imap
->l_tls_offset
608 == GL(dl_tls_static_used
))
609 GL(dl_tls_static_used
)
610 = imap
->l_tls_offset
- imap
->l_tls_blocksize
;
611 else if (tls_free_end
< (size_t) imap
->l_tls_offset
)
613 /* We pick the later block. It has a chance to
615 tls_free_end
= imap
->l_tls_offset
;
617 = tls_free_end
- imap
->l_tls_blocksize
;
621 if (tls_free_start
== NO_TLS_OFFSET
)
623 tls_free_start
= imap
->l_tls_firstbyte_offset
;
624 tls_free_end
= (imap
->l_tls_offset
625 + imap
->l_tls_blocksize
);
627 else if (imap
->l_tls_firstbyte_offset
== tls_free_end
)
628 /* Extend the contiguous chunk being reclaimed. */
629 tls_free_end
= imap
->l_tls_offset
+ imap
->l_tls_blocksize
;
630 else if (imap
->l_tls_offset
+ imap
->l_tls_blocksize
632 /* Extend the chunk backwards. */
633 tls_free_start
= imap
->l_tls_firstbyte_offset
;
634 /* This isn't contiguous with the last chunk freed.
635 One of them will be leaked unless we can free
636 one block right away. */
637 else if (imap
->l_tls_offset
+ imap
->l_tls_blocksize
638 == GL(dl_tls_static_used
))
639 GL(dl_tls_static_used
) = imap
->l_tls_firstbyte_offset
;
640 else if (tls_free_end
== GL(dl_tls_static_used
))
642 GL(dl_tls_static_used
) = tls_free_start
;
643 tls_free_start
= imap
->l_tls_firstbyte_offset
;
644 tls_free_end
= imap
->l_tls_offset
+ imap
->l_tls_blocksize
;
646 else if (tls_free_end
< imap
->l_tls_firstbyte_offset
)
648 /* We pick the later block. It has a chance to
650 tls_free_start
= imap
->l_tls_firstbyte_offset
;
651 tls_free_end
= imap
->l_tls_offset
+ imap
->l_tls_blocksize
;
654 # error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
659 /* Reset unique symbols if forced. */
662 struct unique_sym_table
*tab
= &ns
->_ns_unique_sym_table
;
663 __rtld_lock_lock_recursive (tab
->lock
);
664 struct unique_sym
*entries
= tab
->entries
;
667 size_t idx
, size
= tab
->size
;
668 for (idx
= 0; idx
< size
; ++idx
)
670 /* Clear unique symbol entries that belong to this
672 if (entries
[idx
].name
!= NULL
673 && entries
[idx
].map
== imap
)
675 entries
[idx
].name
= NULL
;
676 entries
[idx
].hashval
= 0;
681 __rtld_lock_unlock_recursive (tab
->lock
);
684 /* We can unmap all the maps at once. We determined the
685 start address and length when we loaded the object and
686 the `munmap' call does the rest. */
689 /* Finally, unlink the data structure and free it. */
691 /* The assert in the (imap->l_prev == NULL) case gives
692 the compiler license to warn that NS points outside
693 the dl_ns array bounds in that case (as nsid != LM_ID_BASE
694 is tantamount to nsid >= DL_NNS). That should be impossible
695 in this configuration, so just assert about it instead. */
696 assert (nsid
== LM_ID_BASE
);
697 assert (imap
->l_prev
!= NULL
);
699 if (imap
->l_prev
== NULL
)
701 assert (nsid
!= LM_ID_BASE
);
702 ns
->_ns_loaded
= imap
->l_next
;
704 /* Update the pointer to the head of the list
705 we leave for debuggers to examine. */
706 r
->r_map
= (void *) ns
->_ns_loaded
;
710 imap
->l_prev
->l_next
= imap
->l_next
;
713 if (imap
->l_next
!= NULL
)
714 imap
->l_next
->l_prev
= imap
->l_prev
;
716 free (imap
->l_versions
);
717 if (imap
->l_origin
!= (char *) -1)
718 free ((char *) imap
->l_origin
);
720 free (imap
->l_reldeps
);
722 /* Print debugging message. */
723 if (__glibc_unlikely (GLRO(dl_debug_mask
) & DL_DEBUG_FILES
))
724 _dl_debug_printf ("\nfile=%s [%lu]; destroying link map\n",
725 imap
->l_name
, imap
->l_ns
);
727 /* This name always is allocated. */
729 /* Remove the list with all the names of the shared object. */
731 struct libname_list
*lnp
= imap
->l_libname
;
734 struct libname_list
*this = lnp
;
736 if (!this->dont_free
)
741 /* Remove the searchlists. */
742 free (imap
->l_initfini
);
744 /* Remove the scope array if we allocated it. */
745 if (imap
->l_scope
!= imap
->l_scope_mem
)
746 free (imap
->l_scope
);
748 if (imap
->l_phdr_allocated
)
749 free ((void *) imap
->l_phdr
);
751 if (imap
->l_rpath_dirs
.dirs
!= (void *) -1)
752 free (imap
->l_rpath_dirs
.dirs
);
753 if (imap
->l_runpath_dirs
.dirs
!= (void *) -1)
754 free (imap
->l_runpath_dirs
.dirs
);
760 __rtld_lock_unlock_recursive (GL(dl_load_write_lock
));
762 /* If we removed any object which uses TLS bump the generation counter. */
765 if (__glibc_unlikely (++GL(dl_tls_generation
) == 0))
766 _dl_fatal_printf ("TLS generation counter wrapped! Please report as described in "REPORT_BUGS_TO
".\n");
768 if (tls_free_end
== GL(dl_tls_static_used
))
769 GL(dl_tls_static_used
) = tls_free_start
;
773 /* Auditing checkpoint: we have deleted all objects. */
774 if (__glibc_unlikely (do_audit
))
776 struct link_map
*head
= ns
->_ns_loaded
;
777 /* Do not call the functions for any auditing object. */
778 if (head
->l_auditing
== 0)
780 struct audit_ifaces
*afct
= GLRO(dl_audit
);
781 for (unsigned int cnt
= 0; cnt
< GLRO(dl_naudit
); ++cnt
)
783 if (afct
->activity
!= NULL
)
785 struct auditstate
*state
= link_map_audit_state (head
, cnt
);
786 afct
->activity (&state
->cookie
, LA_ACT_CONSISTENT
);
795 if (__builtin_expect (ns
->_ns_loaded
== NULL
, 0)
796 && nsid
== GL(dl_nns
) - 1)
799 while (GL(dl_ns
)[GL(dl_nns
) - 1]._ns_loaded
== NULL
);
801 /* Notify the debugger those objects are finalized and gone. */
802 r
->r_state
= RT_CONSISTENT
;
804 LIBC_PROBE (unmap_complete
, 2, nsid
, r
);
806 /* Recheck if we need to retry, release the lock. */
808 if (dl_close_state
== rerun
)
811 dl_close_state
= not_pending
;
816 _dl_close (void *_map
)
818 struct link_map
*map
= _map
;
820 /* We must take the lock to examine the contents of map and avoid
821 concurrent dlopens. */
822 __rtld_lock_lock_recursive (GL(dl_load_lock
));
824 /* At this point we are guaranteed nobody else is touching the list of
825 loaded maps, but a concurrent dlclose might have freed our map
826 before we took the lock. There is no way to detect this (see below)
827 so we proceed assuming this isn't the case. First see whether we
828 can remove the object at all. */
829 if (__glibc_unlikely (map
->l_flags_1
& DF_1_NODELETE
))
831 /* Nope. Do nothing. */
832 __rtld_lock_unlock_recursive (GL(dl_load_lock
));
836 /* At present this is an unreliable check except in the case where the
837 caller has recursively called dlclose and we are sure the link map
838 has not been freed. In a non-recursive dlclose the map itself
839 might have been freed and this access is potentially a data race
840 with whatever other use this memory might have now, or worse we
841 might silently corrupt memory if it looks enough like a link map.
842 POSIX has language in dlclose that appears to guarantee that this
843 should be a detectable case and given that dlclose should be threadsafe
844 we need this to be a reliable detection.
845 This is bug 20990. */
846 if (__builtin_expect (map
->l_direct_opencount
, 1) == 0)
848 __rtld_lock_unlock_recursive (GL(dl_load_lock
));
849 _dl_signal_error (0, map
->l_name
, NULL
, N_("shared object not open"));
852 _dl_close_worker (map
, false);
854 __rtld_lock_unlock_recursive (GL(dl_load_lock
));