]>
Commit | Line | Data |
---|---|---|
efec1d0c | 1 | /* Load the dependencies of a mapped object. |
afdca0f2 | 2 | Copyright (C) 1996-2003, 2004 Free Software Foundation, Inc. |
afd4eb37 UD |
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 | |
41bdb6e2 AJ |
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. | |
afd4eb37 UD |
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 | |
41bdb6e2 | 13 | Lesser General Public License for more details. |
afd4eb37 | 14 | |
41bdb6e2 AJ |
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 | |
18 | 02111-1307 USA. */ | |
efec1d0c | 19 | |
dc5efe83 | 20 | #include <assert.h> |
efec1d0c | 21 | #include <dlfcn.h> |
a853022c | 22 | #include <errno.h> |
8e17ea58 | 23 | #include <libintl.h> |
32e6df36 | 24 | #include <stddef.h> |
efec1d0c | 25 | #include <stdlib.h> |
ca34d7a7 | 26 | #include <string.h> |
06535ae9 | 27 | #include <unistd.h> |
dc5efe83 | 28 | #include <sys/param.h> |
a42195db | 29 | #include <ldsodefs.h> |
a853022c | 30 | |
dc5efe83 | 31 | #include <dl-dst.h> |
1522c368 UD |
32 | |
33 | /* Whether an shared object references one or more auxiliary objects | |
34 | is signaled by the AUXTAG entry in l_info. */ | |
b0982c4a | 35 | #define AUXTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \ |
1522c368 | 36 | + DT_EXTRATAGIDX (DT_AUXILIARY)) |
f41c8091 UD |
37 | /* Whether an shared object references one or more auxiliary objects |
38 | is signaled by the AUXTAG entry in l_info. */ | |
b0982c4a | 39 | #define FILTERTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \ |
f41c8091 | 40 | + DT_EXTRATAGIDX (DT_FILTER)) |
1522c368 UD |
41 | |
42 | ||
43 | /* When loading auxiliary objects we must ignore errors. It's ok if | |
44 | an object is missing. */ | |
993b3242 | 45 | struct openaux_args |
1522c368 UD |
46 | { |
47 | /* The arguments to openaux. */ | |
48 | struct link_map *map; | |
49 | int trace_mode; | |
87837aac | 50 | int open_mode; |
1522c368 | 51 | const char *strtab; |
dc5efe83 | 52 | const char *name; |
993b3242 | 53 | |
1522c368 UD |
54 | /* The return value of openaux. */ |
55 | struct link_map *aux; | |
56 | }; | |
993b3242 UD |
57 | |
58 | static void | |
59 | openaux (void *a) | |
60 | { | |
61 | struct openaux_args *args = (struct openaux_args *) a; | |
62 | ||
cff26a3e AJ |
63 | args->aux = INTUSE(_dl_map_object) (args->map, args->name, 0, |
64 | (args->map->l_type == lt_executable | |
65 | ? lt_library : args->map->l_type), | |
87837aac | 66 | args->trace_mode, args->open_mode); |
993b3242 UD |
67 | } |
68 | ||
32e6df36 UD |
69 | static ptrdiff_t |
70 | internal_function | |
71 | _dl_build_local_scope (struct link_map **list, struct link_map *map) | |
72 | { | |
73 | struct link_map **p = list; | |
74 | struct link_map **q; | |
75 | ||
76 | *p++ = map; | |
77 | map->l_reserved = 1; | |
78 | if (map->l_initfini) | |
79 | for (q = map->l_initfini + 1; *q; ++q) | |
80 | if (! (*q)->l_reserved) | |
81 | p += _dl_build_local_scope (p, *q); | |
82 | return p - list; | |
83 | } | |
1522c368 UD |
84 | |
85 | ||
80d9c5f0 | 86 | /* We use a very special kind of list to track the path |
1522c368 | 87 | through the list of loaded shared objects. We have to |
80d9c5f0 | 88 | produce a flat list with unique members of all involved objects. |
1522c368 UD |
89 | */ |
90 | struct list | |
91 | { | |
92 | int done; /* Nonzero if this map was processed. */ | |
93 | struct link_map *map; /* The data. */ | |
80d9c5f0 | 94 | struct list *next; /* Elements for normal list. */ |
1522c368 UD |
95 | }; |
96 | ||
97 | ||
dc5efe83 UD |
98 | /* Macro to expand DST. It is an macro since we use `alloca'. */ |
99 | #define expand_dst(l, str, fatal) \ | |
100 | ({ \ | |
101 | const char *__str = (str); \ | |
102 | const char *__result = __str; \ | |
103 | size_t __cnt = DL_DST_COUNT(__str, 0); \ | |
104 | \ | |
105 | if (__cnt != 0) \ | |
106 | { \ | |
06535ae9 UD |
107 | char *__newp; \ |
108 | \ | |
109 | /* DST must not appear in SUID/SGID programs. */ \ | |
e6caf4e1 | 110 | if (INTUSE(__libc_enable_secure)) \ |
87837aac UD |
111 | INTUSE(_dl_signal_error) (0, __str, NULL, N_("\ |
112 | DST not allowed in SUID/SGID programs")); \ | |
06535ae9 UD |
113 | \ |
114 | __newp = (char *) alloca (DL_DST_REQUIRED (l, __str, strlen (__str), \ | |
115 | __cnt)); \ | |
dc5efe83 | 116 | \ |
cff26a3e | 117 | __result = INTUSE(_dl_dst_substitute) (l, __str, __newp, 0); \ |
dc5efe83 UD |
118 | \ |
119 | if (*__result == '\0') \ | |
120 | { \ | |
121 | /* The replacement for the DST is not known. We can't \ | |
122 | processed. */ \ | |
123 | if (fatal) \ | |
cff26a3e | 124 | INTUSE(_dl_signal_error) (0, __str, NULL, N_("\ |
8e17ea58 | 125 | empty dynamics string token substitution")); \ |
dc5efe83 UD |
126 | else \ |
127 | { \ | |
128 | /* This is for DT_AUXILIARY. */ \ | |
afdca0f2 | 129 | if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))\ |
cff26a3e | 130 | INTUSE(_dl_debug_printf) (N_("\ |
7969407a UD |
131 | cannot load auxiliary `%s' because of empty dynamic string token " \ |
132 | "substitution\n"), __str); \ | |
dc5efe83 UD |
133 | continue; \ |
134 | } \ | |
135 | } \ | |
136 | } \ | |
137 | \ | |
138 | __result; }) | |
139 | ||
140 | ||
d9cb1a7d | 141 | void |
d0fc4041 | 142 | internal_function |
2064087b | 143 | _dl_map_object_deps (struct link_map *map, |
46ec036d | 144 | struct link_map **preloads, unsigned int npreloads, |
87837aac | 145 | int trace_mode, int open_mode) |
efec1d0c | 146 | { |
1522c368 | 147 | struct list known[1 + npreloads + 1]; |
80d9c5f0 UD |
148 | struct list *runp, *tail; |
149 | unsigned int nlist, i; | |
c77a4478 UD |
150 | /* Object name. */ |
151 | const char *name; | |
152 | int errno_saved; | |
153 | int errno_reason; | |
951d5dd8 | 154 | const char *errstring; |
64b7897d | 155 | const char *objname; |
1522c368 | 156 | |
938c669e AJ |
157 | auto inline void preload (struct link_map *map); |
158 | ||
df4ef2ab UD |
159 | inline void preload (struct link_map *map) |
160 | { | |
1522c368 UD |
161 | known[nlist].done = 0; |
162 | known[nlist].map = map; | |
80d9c5f0 | 163 | known[nlist].next = &known[nlist + 1]; |
efec1d0c | 164 | |
1522c368 | 165 | ++nlist; |
df4ef2ab UD |
166 | /* We use `l_reserved' as a mark bit to detect objects we have |
167 | already put in the search list and avoid adding duplicate | |
168 | elements later in the list. */ | |
169 | map->l_reserved = 1; | |
170 | } | |
2064087b | 171 | |
1522c368 UD |
172 | /* No loaded object so far. */ |
173 | nlist = 0; | |
2064087b | 174 | |
1522c368 | 175 | /* First load MAP itself. */ |
df4ef2ab UD |
176 | preload (map); |
177 | ||
178 | /* Add the preloaded items after MAP but before any of its dependencies. */ | |
179 | for (i = 0; i < npreloads; ++i) | |
180 | preload (preloads[i]); | |
181 | ||
8a523922 | 182 | /* Terminate the lists. */ |
80d9c5f0 | 183 | known[nlist - 1].next = NULL; |
1522c368 | 184 | |
1522c368 | 185 | /* Pointer to last unique object. */ |
80d9c5f0 | 186 | tail = &known[nlist - 1]; |
efec1d0c | 187 | |
1522c368 UD |
188 | /* Process each element of the search list, loading each of its |
189 | auxiliary objects and immediate dependencies. Auxiliary objects | |
190 | will be added in the list before the object itself and | |
191 | dependencies will be appended to the list as we step through it. | |
192 | This produces a flat, ordered list that represents a | |
193 | breadth-first search of the dependency tree. | |
194 | ||
195 | The whole process is complicated by the fact that we better | |
196 | should use alloca for the temporary list elements. But using | |
197 | alloca means we cannot use recursive function calls. */ | |
c77a4478 UD |
198 | errno_saved = errno; |
199 | errno_reason = 0; | |
951d5dd8 | 200 | errstring = NULL; |
c77a4478 UD |
201 | errno = 0; |
202 | name = NULL; | |
1522c368 | 203 | for (runp = known; runp; ) |
efec1d0c | 204 | { |
1522c368 | 205 | struct link_map *l = runp->map; |
dacc8ffa UD |
206 | struct link_map **needed = NULL; |
207 | unsigned int nneeded = 0; | |
208 | ||
209 | /* Unless otherwise stated, this object is handled. */ | |
210 | runp->done = 1; | |
211 | ||
212 | /* Allocate a temporary record to contain the references to the | |
213 | dependencies of this object. */ | |
07a3d63e UD |
214 | if (l->l_searchlist.r_list == NULL && l->l_initfini == NULL |
215 | && l != map && l->l_ldnum > 0) | |
dacc8ffa UD |
216 | needed = (struct link_map **) alloca (l->l_ldnum |
217 | * sizeof (struct link_map *)); | |
f68b86cc | 218 | |
8193034b | 219 | if (l->l_info[DT_NEEDED] || l->l_info[AUXTAG] || l->l_info[FILTERTAG]) |
efec1d0c | 220 | { |
a42195db | 221 | const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]); |
1522c368 UD |
222 | struct openaux_args args; |
223 | struct list *orig; | |
266180eb | 224 | const ElfW(Dyn) *d; |
1522c368 | 225 | |
1522c368 UD |
226 | args.strtab = strtab; |
227 | args.map = l; | |
228 | args.trace_mode = trace_mode; | |
87837aac | 229 | args.open_mode = open_mode; |
1522c368 UD |
230 | orig = runp; |
231 | ||
efec1d0c | 232 | for (d = l->l_ld; d->d_tag != DT_NULL; ++d) |
e3e35cfc | 233 | if (__builtin_expect (d->d_tag, DT_NEEDED) == DT_NEEDED) |
efec1d0c | 234 | { |
f68b86cc | 235 | /* Map in the needed object. */ |
dc5efe83 | 236 | struct link_map *dep; |
505d4b24 | 237 | int err; |
dc5efe83 UD |
238 | |
239 | /* Recognize DSTs. */ | |
240 | name = expand_dst (l, strtab + d->d_un.d_val, 0); | |
c77a4478 UD |
241 | /* Store the tag in the argument structure. */ |
242 | args.name = name; | |
dc5efe83 | 243 | |
cff26a3e AJ |
244 | err = INTUSE(_dl_catch_error) (&objname, &errstring, openaux, |
245 | &args); | |
505d4b24 | 246 | if (__builtin_expect (errstring != NULL, 0)) |
c77a4478 | 247 | { |
505d4b24 UD |
248 | if (err) |
249 | errno_reason = err; | |
c77a4478 UD |
250 | else |
251 | errno_reason = -1; | |
252 | goto out; | |
253 | } | |
254 | else | |
255 | dep = args.aux; | |
1522c368 | 256 | |
42c4f32a | 257 | if (! dep->l_reserved) |
efec1d0c | 258 | { |
80d9c5f0 UD |
259 | /* Allocate new entry. */ |
260 | struct list *newp; | |
261 | ||
262 | newp = alloca (sizeof (struct list)); | |
263 | ||
264 | /* Append DEP to the list. */ | |
265 | newp->map = dep; | |
1522c368 | 266 | newp->done = 0; |
80d9c5f0 UD |
267 | newp->next = NULL; |
268 | tail->next = newp; | |
269 | tail = newp; | |
f68b86cc | 270 | ++nlist; |
f9496a7b RM |
271 | /* Set the mark bit that says it's already in the list. */ |
272 | dep->l_reserved = 1; | |
efec1d0c | 273 | } |
dacc8ffa UD |
274 | |
275 | /* Remember this dependency. */ | |
276 | if (needed != NULL) | |
277 | needed[nneeded++] = dep; | |
1522c368 | 278 | } |
f41c8091 | 279 | else if (d->d_tag == DT_AUXILIARY || d->d_tag == DT_FILTER) |
1522c368 | 280 | { |
f41c8091 | 281 | struct list *newp; |
dc5efe83 UD |
282 | |
283 | /* Recognize DSTs. */ | |
284 | name = expand_dst (l, strtab + d->d_un.d_val, | |
285 | d->d_tag == DT_AUXILIARY); | |
c77a4478 UD |
286 | /* Store the tag in the argument structure. */ |
287 | args.name = name; | |
84384f5b | 288 | |
f41c8091 | 289 | if (d->d_tag == DT_AUXILIARY) |
1522c368 | 290 | { |
505d4b24 UD |
291 | int err; |
292 | ||
8d9618b7 | 293 | /* Say that we are about to load an auxiliary library. */ |
afdca0f2 | 294 | if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, |
d6b5d570 | 295 | 0)) |
cff26a3e | 296 | INTUSE(_dl_debug_printf) ("load auxiliary object=%s" |
87837aac UD |
297 | " requested by file=%s\n", |
298 | name, | |
cff26a3e | 299 | l->l_name[0] |
e6caf4e1 | 300 | ? l->l_name : rtld_progname); |
8d9618b7 | 301 | |
f41c8091 UD |
302 | /* We must be prepared that the addressed shared |
303 | object is not available. */ | |
87837aac UD |
304 | err = INTUSE(_dl_catch_error) (&objname, &errstring, |
305 | openaux, &args); | |
505d4b24 | 306 | if (__builtin_expect (errstring != NULL, 0)) |
f41c8091 UD |
307 | { |
308 | /* We are not interested in the error message. */ | |
309 | assert (errstring != NULL); | |
e6caf4e1 | 310 | if (errstring != INTUSE(_dl_out_of_memory)) |
ca3c0135 | 311 | free ((char *) errstring); |
f41c8091 UD |
312 | |
313 | /* Simply ignore this error and continue the work. */ | |
314 | continue; | |
315 | } | |
1522c368 UD |
316 | } |
317 | else | |
8d9618b7 | 318 | { |
505d4b24 UD |
319 | int err; |
320 | ||
8d9618b7 | 321 | /* Say that we are about to load an auxiliary library. */ |
afdca0f2 | 322 | if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, |
d6b5d570 | 323 | 0)) |
cff26a3e | 324 | INTUSE(_dl_debug_printf) ("load filtered object=%s" |
87837aac UD |
325 | " requested by file=%s\n", |
326 | name, | |
cff26a3e | 327 | l->l_name[0] |
e6caf4e1 | 328 | ? l->l_name : rtld_progname); |
8d9618b7 UD |
329 | |
330 | /* For filter objects the dependency must be available. */ | |
87837aac UD |
331 | err = INTUSE(_dl_catch_error) (&objname, &errstring, |
332 | openaux, &args); | |
505d4b24 | 333 | if (__builtin_expect (errstring != NULL, 0)) |
c77a4478 | 334 | { |
505d4b24 UD |
335 | if (err) |
336 | errno_reason = err; | |
c77a4478 UD |
337 | else |
338 | errno_reason = -1; | |
339 | goto out; | |
340 | } | |
8d9618b7 | 341 | } |
f41c8091 UD |
342 | |
343 | /* The auxiliary object is actually available. | |
344 | Incorporate the map in all the lists. */ | |
345 | ||
346 | /* Allocate new entry. This always has to be done. */ | |
347 | newp = alloca (sizeof (struct list)); | |
348 | ||
ee0f7bd6 UD |
349 | /* We want to insert the new map before the current one, |
350 | but we have no back links. So we copy the contents of | |
351 | the current entry over. Note that ORIG and NEWP now | |
352 | have switched their meanings. */ | |
80d9c5f0 | 353 | memcpy (newp, orig, sizeof (*newp)); |
f41c8091 UD |
354 | |
355 | /* Initialize new entry. */ | |
356 | orig->done = 0; | |
357 | orig->map = args.aux; | |
f41c8091 | 358 | |
dacc8ffa UD |
359 | /* Remember this dependency. */ |
360 | if (needed != NULL) | |
361 | needed[nneeded++] = args.aux; | |
362 | ||
f41c8091 UD |
363 | /* We must handle two situations here: the map is new, |
364 | so we must add it in all three lists. If the map | |
365 | is already known, we have two further possibilities: | |
366 | - if the object is before the current map in the | |
367 | search list, we do nothing. It is already found | |
368 | early | |
369 | - if the object is after the current one, we must | |
370 | move it just before the current map to make sure | |
371 | the symbols are found early enough | |
372 | */ | |
373 | if (args.aux->l_reserved) | |
1522c368 | 374 | { |
f41c8091 UD |
375 | /* The object is already somewhere in the list. |
376 | Locate it first. */ | |
377 | struct list *late; | |
378 | ||
379 | /* This object is already in the search list we | |
380 | are building. Don't add a duplicate pointer. | |
42c4f32a | 381 | Just added by _dl_map_object. */ |
23382b36 | 382 | for (late = newp; late->next != NULL; late = late->next) |
80d9c5f0 | 383 | if (late->next->map == args.aux) |
f41c8091 UD |
384 | break; |
385 | ||
23382b36 | 386 | if (late->next != NULL) |
1522c368 | 387 | { |
f41c8091 UD |
388 | /* The object is somewhere behind the current |
389 | position in the search path. We have to | |
390 | move it to this earlier position. */ | |
80d9c5f0 | 391 | orig->next = newp; |
f41c8091 | 392 | |
80d9c5f0 | 393 | /* Now remove the later entry from the list |
ee0f7bd6 | 394 | and adjust the tail pointer. */ |
80d9c5f0 UD |
395 | if (tail == late->next) |
396 | tail = late; | |
397 | late->next = late->next->next; | |
f41c8091 | 398 | |
ee0f7bd6 | 399 | /* We must move the object earlier in the chain. */ |
23382b36 | 400 | if (args.aux->l_prev != NULL) |
1522c368 | 401 | args.aux->l_prev->l_next = args.aux->l_next; |
23382b36 | 402 | if (args.aux->l_next != NULL) |
1522c368 UD |
403 | args.aux->l_next->l_prev = args.aux->l_prev; |
404 | ||
405 | args.aux->l_prev = newp->map->l_prev; | |
406 | newp->map->l_prev = args.aux; | |
407 | if (args.aux->l_prev != NULL) | |
408 | args.aux->l_prev->l_next = args.aux; | |
409 | args.aux->l_next = newp->map; | |
410 | } | |
f41c8091 UD |
411 | else |
412 | { | |
413 | /* The object must be somewhere earlier in the | |
23382b36 UD |
414 | list. Undo to the current list element what |
415 | we did above. */ | |
416 | memcpy (orig, newp, sizeof (*newp)); | |
417 | continue; | |
f41c8091 UD |
418 | } |
419 | } | |
420 | else | |
421 | { | |
422 | /* This is easy. We just add the symbol right here. */ | |
80d9c5f0 | 423 | orig->next = newp; |
f41c8091 UD |
424 | ++nlist; |
425 | /* Set the mark bit that says it's already in the list. */ | |
426 | args.aux->l_reserved = 1; | |
427 | ||
428 | /* The only problem is that in the double linked | |
429 | list of all objects we don't have this new | |
430 | object at the correct place. Correct this here. */ | |
431 | if (args.aux->l_prev) | |
432 | args.aux->l_prev->l_next = args.aux->l_next; | |
433 | if (args.aux->l_next) | |
434 | args.aux->l_next->l_prev = args.aux->l_prev; | |
435 | ||
436 | args.aux->l_prev = newp->map->l_prev; | |
437 | newp->map->l_prev = args.aux; | |
438 | if (args.aux->l_prev != NULL) | |
439 | args.aux->l_prev->l_next = args.aux; | |
440 | args.aux->l_next = newp->map; | |
441 | } | |
1522c368 | 442 | |
80d9c5f0 UD |
443 | /* Move the tail pointer if necessary. */ |
444 | if (orig == tail) | |
445 | tail = newp; | |
1522c368 | 446 | |
f41c8091 UD |
447 | /* Move on the insert point. */ |
448 | orig = newp; | |
efec1d0c RM |
449 | } |
450 | } | |
dacc8ffa UD |
451 | |
452 | /* Terminate the list of dependencies and store the array address. */ | |
453 | if (needed != NULL) | |
454 | { | |
455 | needed[nneeded++] = NULL; | |
456 | ||
c4bb124a | 457 | l->l_initfini = (struct link_map **) |
aff4519d | 458 | malloc ((2 * nneeded + 1) * sizeof needed[0]); |
dacc8ffa | 459 | if (l->l_initfini == NULL) |
cff26a3e AJ |
460 | INTUSE(_dl_signal_error) (ENOMEM, map->l_name, NULL, |
461 | N_("cannot allocate dependency list")); | |
c4bb124a UD |
462 | l->l_initfini[0] = l; |
463 | memcpy (&l->l_initfini[1], needed, nneeded * sizeof needed[0]); | |
aff4519d UD |
464 | memcpy (&l->l_initfini[nneeded + 1], l->l_initfini, |
465 | nneeded * sizeof needed[0]); | |
dacc8ffa | 466 | } |
1522c368 UD |
467 | |
468 | /* If we have no auxiliary objects just go on to the next map. */ | |
469 | if (runp->done) | |
470 | do | |
80d9c5f0 | 471 | runp = runp->next; |
8193034b | 472 | while (runp != NULL && runp->done); |
efec1d0c RM |
473 | } |
474 | ||
c4bb124a | 475 | out: |
c77a4478 UD |
476 | if (errno == 0 && errno_saved != 0) |
477 | __set_errno (errno_saved); | |
478 | ||
752a2a50 UD |
479 | if (map->l_initfini != NULL && map->l_type == lt_loaded) |
480 | { | |
481 | /* This object was previously loaded as a dependency and we have | |
482 | a separate l_initfini list. We don't need it anymore. */ | |
483 | assert (map->l_searchlist.r_list == NULL); | |
484 | free (map->l_initfini); | |
485 | } | |
486 | ||
f68b86cc RM |
487 | /* Store the search list we built in the object. It will be used for |
488 | searches in the scope of this object. */ | |
2e93b4a4 | 489 | map->l_initfini = |
80d9c5f0 | 490 | (struct link_map **) malloc ((2 * nlist + 1) |
2e93b4a4 UD |
491 | * sizeof (struct link_map *)); |
492 | if (map->l_initfini == NULL) | |
cff26a3e AJ |
493 | INTUSE(_dl_signal_error) (ENOMEM, map->l_name, NULL, |
494 | N_("cannot allocate symbol search list")); | |
2e93b4a4 UD |
495 | |
496 | ||
497 | map->l_searchlist.r_list = &map->l_initfini[nlist + 1]; | |
be935610 | 498 | map->l_searchlist.r_nlist = nlist; |
f68b86cc | 499 | |
80d9c5f0 | 500 | for (nlist = 0, runp = known; runp; runp = runp->next) |
f68b86cc | 501 | { |
c4bb124a | 502 | if (__builtin_expect (trace_mode, 0) && runp->map->l_faked) |
ad9570d7 UD |
503 | /* This can happen when we trace the loading. */ |
504 | --map->l_searchlist.r_nlist; | |
505 | else | |
506 | map->l_searchlist.r_list[nlist++] = runp->map; | |
f68b86cc RM |
507 | |
508 | /* Now clear all the mark bits we set in the objects on the search list | |
509 | to avoid duplicates, so the next call starts fresh. */ | |
1522c368 | 510 | runp->map->l_reserved = 0; |
f68b86cc | 511 | } |
84384f5b | 512 | |
afdca0f2 | 513 | if (__builtin_expect(GLRO(dl_debug_mask) & DL_DEBUG_PRELINK, 0) != 0 |
d6b5d570 | 514 | && map == GL(dl_loaded)) |
32e6df36 UD |
515 | { |
516 | /* If we are to compute conflicts, we have to build local scope | |
517 | for each library, not just the ultimate loader. */ | |
518 | for (i = 0; i < nlist; ++i) | |
519 | { | |
520 | struct link_map *l = map->l_searchlist.r_list[i]; | |
521 | unsigned int j, cnt; | |
522 | ||
523 | /* The local scope has been already computed. */ | |
524 | if (l == map | |
525 | || (l->l_local_scope[0] | |
526 | && l->l_local_scope[0]->r_nlist) != 0) | |
527 | continue; | |
528 | ||
529 | if (l->l_info[AUXTAG] || l->l_info[FILTERTAG]) | |
530 | { | |
531 | /* As current DT_AUXILIARY/DT_FILTER implementation needs to be | |
532 | rewritten, no need to bother with prelinking the old | |
533 | implementation. */ | |
cff26a3e | 534 | INTUSE(_dl_signal_error) (EINVAL, l->l_name, NULL, N_("\ |
32e6df36 UD |
535 | Filters not supported with LD_TRACE_PRELINKING")); |
536 | } | |
537 | ||
538 | cnt = _dl_build_local_scope (map->l_initfini, l); | |
539 | assert (cnt <= nlist); | |
540 | for (j = 0; j < cnt; j++) | |
541 | map->l_initfini[j]->l_reserved = 0; | |
542 | ||
543 | l->l_local_scope[0] = | |
544 | (struct r_scope_elem *) malloc (sizeof (struct r_scope_elem) | |
545 | + (cnt | |
546 | * sizeof (struct link_map *))); | |
547 | if (l->l_local_scope[0] == NULL) | |
cff26a3e AJ |
548 | INTUSE(_dl_signal_error) (ENOMEM, map->l_name, NULL, |
549 | N_("cannot allocate symbol search list")); | |
32e6df36 UD |
550 | l->l_local_scope[0]->r_nlist = cnt; |
551 | l->l_local_scope[0]->r_list = | |
552 | (struct link_map **) (l->l_local_scope[0] + 1); | |
553 | memcpy (l->l_local_scope[0]->r_list, map->l_initfini, | |
554 | cnt * sizeof (struct link_map *)); | |
555 | } | |
556 | } | |
557 | ||
c4bb124a UD |
558 | /* Maybe we can remove some relocation dependencies now. */ |
559 | assert (map->l_searchlist.r_list[0] == map); | |
560 | for (i = 0; i < map->l_reldepsact; ++i) | |
561 | { | |
562 | unsigned int j; | |
563 | ||
564 | for (j = 1; j < nlist; ++j) | |
565 | if (map->l_searchlist.r_list[j] == map->l_reldeps[i]) | |
566 | { | |
567 | /* A direct or transitive dependency is also on the list | |
568 | of relocation dependencies. Remove the latter. */ | |
569 | --map->l_reldeps[i]->l_opencount; | |
570 | ||
571 | for (j = i + 1; j < map->l_reldepsact; ++j) | |
572 | map->l_reldeps[j - 1] = map->l_reldeps[j]; | |
573 | ||
574 | --map->l_reldepsact; | |
575 | ||
576 | /* Account for the '++i' performed by the 'for'. */ | |
577 | --i; | |
578 | break; | |
579 | } | |
580 | } | |
581 | ||
dacc8ffa | 582 | /* Now determine the order in which the initialization has to happen. */ |
2e93b4a4 UD |
583 | memcpy (map->l_initfini, map->l_searchlist.r_list, |
584 | nlist * sizeof (struct link_map *)); | |
dacc8ffa UD |
585 | /* We can skip looking for the binary itself which is at the front |
586 | of the search list. Look through the list backward so that circular | |
587 | dependencies are not changing the order. */ | |
588 | for (i = 1; i < nlist; ++i) | |
589 | { | |
590 | struct link_map *l = map->l_searchlist.r_list[i]; | |
591 | unsigned int j; | |
592 | unsigned int k; | |
593 | ||
594 | /* Find the place in the initfini list where the map is currently | |
595 | located. */ | |
596 | for (j = 1; map->l_initfini[j] != l; ++j) | |
597 | ; | |
598 | ||
599 | /* Find all object for which the current one is a dependency and | |
600 | move the found object (if necessary) in front. */ | |
601 | for (k = j + 1; k < nlist; ++k) | |
602 | { | |
603 | struct link_map **runp; | |
604 | ||
605 | runp = map->l_initfini[k]->l_initfini; | |
606 | if (runp != NULL) | |
607 | { | |
608 | while (*runp != NULL) | |
407fe3bb | 609 | if (__builtin_expect (*runp++ == l, 0)) |
dacc8ffa UD |
610 | { |
611 | struct link_map *here = map->l_initfini[k]; | |
612 | ||
613 | /* Move it now. */ | |
614 | memmove (&map->l_initfini[j] + 1, | |
615 | &map->l_initfini[j], | |
616 | (k - j) * sizeof (struct link_map *)); | |
617 | map->l_initfini[j] = here; | |
618 | ||
8693ad52 UD |
619 | /* Don't insert further matches before the last |
620 | entry moved to the front. */ | |
621 | ++j; | |
622 | ||
dacc8ffa UD |
623 | break; |
624 | } | |
dacc8ffa UD |
625 | } |
626 | } | |
627 | } | |
a8571d37 AJ |
628 | /* Terminate the list of dependencies. */ |
629 | map->l_initfini[nlist] = NULL; | |
c77a4478 UD |
630 | |
631 | if (errno_reason) | |
cff26a3e | 632 | INTUSE(_dl_signal_error) (errno_reason == -1 ? 0 : errno_reason, objname, |
7969407a | 633 | NULL, errstring); |
efec1d0c | 634 | } |
7969407a | 635 | INTDEF (_dl_map_object_deps) |