Update.
[glibc.git] / elf / dl-close.c
blob8caa2973d9d4c09f9b6299e51848117141cf01c6
1 /* Close a shared object opened by `_dl_open'.
2 Copyright (C) 1996, 1997, 1998, 1999 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 Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 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 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
20 #include <assert.h>
21 #include <dlfcn.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <bits/libc-lock.h>
25 #include <elf/ldsodefs.h>
26 #include <sys/types.h>
27 #include <sys/mman.h>
30 /* During the program run we must not modify the global data of
31 loaded shared object simultanously in two threads. Therefore we
32 protect `dlopen' and `dlclose' in dlclose.c. */
33 __libc_lock_define (extern, _dl_load_lock)
35 #define LOSE(s) _dl_signal_error (0, map->l_name, s)
37 void
38 internal_function
39 _dl_close (struct link_map *map)
41 struct link_map **list;
42 unsigned nsearchlist;
43 unsigned int i;
45 if (map->l_opencount == 0)
46 LOSE ("shared object not open");
48 /* Acquire the lock. */
49 __libc_lock_lock (_dl_load_lock);
51 /* Decrement the reference count. */
52 if (map->l_opencount > 1 || map->l_type != lt_loaded)
54 /* There are still references to this object. Do nothing more. */
55 --map->l_opencount;
56 __libc_lock_unlock (_dl_load_lock);
57 return;
60 list = map->l_searchlist.r_list;
61 nsearchlist = map->l_searchlist.r_nlist;
63 /* Call all termination functions at once. */
64 for (i = 0; i < nsearchlist; ++i)
66 struct link_map *imap = list[i];
67 if (imap->l_opencount == 1 && imap->l_type == lt_loaded
68 && imap->l_info[DT_FINI]
69 /* Skip any half-cooked objects that were never initialized. */
70 && imap->l_init_called)
72 /* When debugging print a message first. */
73 if (_dl_debug_impcalls)
74 _dl_debug_message (1, "\ncalling fini: ", imap->l_name,
75 "\n\n", NULL);
76 /* Call its termination function. */
77 (*(void (*) (void)) ((void *) imap->l_addr
78 + imap->l_info[DT_FINI]->d_un.d_ptr)) ();
82 /* Notify the debugger we are about to remove some loaded objects. */
83 _r_debug.r_state = RT_DELETE;
84 _dl_debug_state ();
86 /* The search list contains a counted reference to each object it
87 points to, the 0th elt being MAP itself. Decrement the reference
88 counts on all the objects MAP depends on. */
89 for (i = 0; i < nsearchlist; ++i)
90 --list[i]->l_opencount;
92 /* Check each element of the search list to see if all references to
93 it are gone. */
94 for (i = 0; i < nsearchlist; ++i)
96 struct link_map *imap = list[i];
97 if (imap->l_opencount == 0 && imap->l_type == lt_loaded)
99 struct libname_list *lnp;
101 /* That was the last reference, and this was a dlopen-loaded
102 object. We can unmap it. */
103 if (imap->l_global)
105 /* This object is in the global scope list. Remove it. */
106 unsigned int cnt = _dl_main_searchlist->r_nlist;
109 if (--cnt < 0)
110 break;
111 while (_dl_main_searchlist->r_list[cnt] != imap);
113 if (cnt >= 0)
115 /* The object was already correctly registered. */
116 while (++cnt < _dl_main_searchlist->r_nlist)
117 _dl_main_searchlist->r_list[cnt - 1]
118 = _dl_main_searchlist->r_list[cnt];
120 --_dl_main_searchlist->r_nlist;
122 else
124 /* This can happen if loading was interrupted by something
125 like a missing symbol in the newly loaded objects. In
126 this case the object is already marked as global but
127 `r_nlist' does not count it in. The pointer is in the
128 `r_list' array so we keep searching in the other
129 direction. */
130 cnt = _dl_main_searchlist->r_nlist;
131 while (_dl_main_searchlist->r_list[cnt] != imap)
133 ++cnt;
134 /* Note that if _dl_global_scope_alloc is zero we
135 should never come here in the first place. */
136 assert (cnt < _dl_global_scope_alloc);
141 /* We can unmap all the maps at once. We determined the
142 start address and length when we loaded the object and
143 the `munmap' call does the rest. */
144 __munmap ((void *) imap->l_map_start,
145 imap->l_map_end - imap->l_map_start);
147 /* Finally, unlink the data structure and free it. */
148 #ifdef PIC
149 /* We will unlink the first object only if this is a statically
150 linked program. */
151 assert (imap->l_prev != NULL);
152 imap->l_prev->l_next = imap->l_next;
153 #else
154 if (imap->l_prev != NULL)
155 imap->l_prev->l_next = imap->l_next;
156 else
157 _dl_loaded = imap->l_next;
158 #endif
159 if (imap->l_next)
160 imap->l_next->l_prev = imap->l_prev;
162 if (imap->l_versions != NULL)
163 free (imap->l_versions);
164 if (imap->l_origin != NULL && imap->l_origin != (char *) -1)
165 free ((char *) imap->l_origin);
167 /* This name always is allocated. */
168 free (imap->l_name);
169 /* Remove the list with all the names of the shared object. */
170 lnp = imap->l_libname;
173 struct libname_list *this = lnp;
174 lnp = lnp->next;
175 free (this);
177 while (lnp != NULL);
179 /* Remove the searchlists. */
180 if (imap->l_searchlist.r_duplist != imap->l_searchlist.r_list)
182 /* If a r_list exists there always also is a r_duplist. */
183 assert (imap->l_searchlist.r_list != NULL);
184 free (imap->l_searchlist.r_duplist);
186 if (imap != map && imap->l_searchlist.r_list != NULL)
187 free (imap->l_searchlist.r_list);
189 free (imap);
193 free (list);
195 if (_dl_global_scope_alloc != 0
196 && _dl_main_searchlist->r_nlist == _dl_initial_searchlist.r_nlist)
198 /* All object dynamically loaded by the program are unloaded. Free
199 the memory allocated for the global scope variable. */
200 struct link_map **old = _dl_main_searchlist->r_list;
202 /* Put the old map in. */
203 _dl_main_searchlist->r_list = _dl_initial_searchlist.r_list;
204 /* Signal that the original map is used. */
205 _dl_global_scope_alloc = 0;
207 /* Now free the old map. */
208 free (old);
211 /* Notify the debugger those objects are finalized and gone. */
212 _r_debug.r_state = RT_CONSISTENT;
213 _dl_debug_state ();
215 /* Release the lock. */
216 __libc_lock_unlock (_dl_load_lock);