hurd: fix _hurd_self_sigstate reference from ____longjmp_chk
[glibc.git] / elf / dl-deps.c
blob6a829877991c73db60345d746fe7a469fb5f25aa
1 /* Load the dependencies of a mapped object.
2 Copyright (C) 1996-2016 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 <http://www.gnu.org/licenses/>. */
19 #include <atomic.h>
20 #include <assert.h>
21 #include <dlfcn.h>
22 #include <errno.h>
23 #include <libintl.h>
24 #include <stddef.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <sys/param.h>
29 #include <ldsodefs.h>
31 #include <dl-dst.h>
33 /* Whether an shared object references one or more auxiliary objects
34 is signaled by the AUXTAG entry in l_info. */
35 #define AUXTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
36 + DT_EXTRATAGIDX (DT_AUXILIARY))
37 /* Whether an shared object references one or more auxiliary objects
38 is signaled by the AUXTAG entry in l_info. */
39 #define FILTERTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
40 + DT_EXTRATAGIDX (DT_FILTER))
43 /* When loading auxiliary objects we must ignore errors. It's ok if
44 an object is missing. */
45 struct openaux_args
47 /* The arguments to openaux. */
48 struct link_map *map;
49 int trace_mode;
50 int open_mode;
51 const char *strtab;
52 const char *name;
54 /* The return value of openaux. */
55 struct link_map *aux;
58 static void
59 openaux (void *a)
61 struct openaux_args *args = (struct openaux_args *) a;
63 args->aux = _dl_map_object (args->map, args->name,
64 (args->map->l_type == lt_executable
65 ? lt_library : args->map->l_type),
66 args->trace_mode, args->open_mode,
67 args->map->l_ns);
70 static ptrdiff_t
71 internal_function
72 _dl_build_local_scope (struct link_map **list, struct link_map *map)
74 struct link_map **p = list;
75 struct link_map **q;
77 *p++ = map;
78 map->l_reserved = 1;
79 if (map->l_initfini)
80 for (q = map->l_initfini + 1; *q; ++q)
81 if (! (*q)->l_reserved)
82 p += _dl_build_local_scope (p, *q);
83 return p - list;
87 /* We use a very special kind of list to track the path
88 through the list of loaded shared objects. We have to
89 produce a flat list with unique members of all involved objects.
91 struct list
93 int done; /* Nonzero if this map was processed. */
94 struct link_map *map; /* The data. */
95 struct list *next; /* Elements for normal list. */
99 /* Macro to expand DST. It is an macro since we use `alloca'. */
100 #define expand_dst(l, str, fatal) \
101 ({ \
102 const char *__str = (str); \
103 const char *__result = __str; \
104 size_t __dst_cnt = DL_DST_COUNT (__str, 0); \
106 if (__dst_cnt != 0) \
108 char *__newp; \
110 /* DST must not appear in SUID/SGID programs. */ \
111 if (__libc_enable_secure) \
112 _dl_signal_error (0, __str, NULL, N_("\
113 DST not allowed in SUID/SGID programs")); \
115 __newp = (char *) alloca (DL_DST_REQUIRED (l, __str, strlen (__str), \
116 __dst_cnt)); \
118 __result = _dl_dst_substitute (l, __str, __newp, 0); \
120 if (*__result == '\0') \
122 /* The replacement for the DST is not known. We can't \
123 processed. */ \
124 if (fatal) \
125 _dl_signal_error (0, __str, NULL, N_("\
126 empty dynamic string token substitution")); \
127 else \
129 /* This is for DT_AUXILIARY. */ \
130 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS)) \
131 _dl_debug_printf (N_("\
132 cannot load auxiliary `%s' because of empty dynamic string token " \
133 "substitution\n"), __str); \
134 continue; \
139 __result; })
141 static void
142 preload (struct list *known, unsigned int *nlist, struct link_map *map)
144 known[*nlist].done = 0;
145 known[*nlist].map = map;
146 known[*nlist].next = &known[*nlist + 1];
148 ++*nlist;
149 /* We use `l_reserved' as a mark bit to detect objects we have
150 already put in the search list and avoid adding duplicate
151 elements later in the list. */
152 map->l_reserved = 1;
155 void
156 internal_function
157 _dl_map_object_deps (struct link_map *map,
158 struct link_map **preloads, unsigned int npreloads,
159 int trace_mode, int open_mode)
161 struct list *known = __alloca (sizeof *known * (1 + npreloads + 1));
162 struct list *runp, *tail;
163 unsigned int nlist, i;
164 /* Object name. */
165 const char *name;
166 int errno_saved;
167 int errno_reason;
168 const char *errstring;
169 const char *objname;
171 /* No loaded object so far. */
172 nlist = 0;
174 /* First load MAP itself. */
175 preload (known, &nlist, map);
177 /* Add the preloaded items after MAP but before any of its dependencies. */
178 for (i = 0; i < npreloads; ++i)
179 preload (known, &nlist, preloads[i]);
181 /* Terminate the lists. */
182 known[nlist - 1].next = NULL;
184 /* Pointer to last unique object. */
185 tail = &known[nlist - 1];
187 /* No alloca'd space yet. */
188 struct link_map **needed_space = NULL;
189 size_t needed_space_bytes = 0;
191 /* Process each element of the search list, loading each of its
192 auxiliary objects and immediate dependencies. Auxiliary objects
193 will be added in the list before the object itself and
194 dependencies will be appended to the list as we step through it.
195 This produces a flat, ordered list that represents a
196 breadth-first search of the dependency tree.
198 The whole process is complicated by the fact that we better
199 should use alloca for the temporary list elements. But using
200 alloca means we cannot use recursive function calls. */
201 errno_saved = errno;
202 errno_reason = 0;
203 errstring = NULL;
204 errno = 0;
205 name = NULL;
206 for (runp = known; runp; )
208 struct link_map *l = runp->map;
209 struct link_map **needed = NULL;
210 unsigned int nneeded = 0;
212 /* Unless otherwise stated, this object is handled. */
213 runp->done = 1;
215 /* Allocate a temporary record to contain the references to the
216 dependencies of this object. */
217 if (l->l_searchlist.r_list == NULL && l->l_initfini == NULL
218 && l != map && l->l_ldnum > 0)
220 size_t new_size = l->l_ldnum * sizeof (struct link_map *);
222 if (new_size > needed_space_bytes)
223 needed_space
224 = extend_alloca (needed_space, needed_space_bytes, new_size);
226 needed = needed_space;
229 if (l->l_info[DT_NEEDED] || l->l_info[AUXTAG] || l->l_info[FILTERTAG])
231 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
232 struct openaux_args args;
233 struct list *orig;
234 const ElfW(Dyn) *d;
236 args.strtab = strtab;
237 args.map = l;
238 args.trace_mode = trace_mode;
239 args.open_mode = open_mode;
240 orig = runp;
242 for (d = l->l_ld; d->d_tag != DT_NULL; ++d)
243 if (__builtin_expect (d->d_tag, DT_NEEDED) == DT_NEEDED)
245 /* Map in the needed object. */
246 struct link_map *dep;
248 /* Recognize DSTs. */
249 name = expand_dst (l, strtab + d->d_un.d_val, 0);
250 /* Store the tag in the argument structure. */
251 args.name = name;
253 bool malloced;
254 int err = _dl_catch_error (&objname, &errstring, &malloced,
255 openaux, &args);
256 if (__glibc_unlikely (errstring != NULL))
258 char *new_errstring = strdupa (errstring);
259 objname = strdupa (objname);
260 if (malloced)
261 free ((char *) errstring);
262 errstring = new_errstring;
264 if (err)
265 errno_reason = err;
266 else
267 errno_reason = -1;
268 goto out;
270 else
271 dep = args.aux;
273 if (! dep->l_reserved)
275 /* Allocate new entry. */
276 struct list *newp;
278 newp = alloca (sizeof (struct list));
280 /* Append DEP to the list. */
281 newp->map = dep;
282 newp->done = 0;
283 newp->next = NULL;
284 tail->next = newp;
285 tail = newp;
286 ++nlist;
287 /* Set the mark bit that says it's already in the list. */
288 dep->l_reserved = 1;
291 /* Remember this dependency. */
292 if (needed != NULL)
293 needed[nneeded++] = dep;
295 else if (d->d_tag == DT_AUXILIARY || d->d_tag == DT_FILTER)
297 struct list *newp;
299 /* Recognize DSTs. */
300 name = expand_dst (l, strtab + d->d_un.d_val,
301 d->d_tag == DT_AUXILIARY);
302 /* Store the tag in the argument structure. */
303 args.name = name;
305 /* Say that we are about to load an auxiliary library. */
306 if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS,
308 _dl_debug_printf ("load auxiliary object=%s"
309 " requested by file=%s\n",
310 name,
311 DSO_FILENAME (l->l_name));
313 /* We must be prepared that the addressed shared
314 object is not available. For filter objects the dependency
315 must be available. */
316 bool malloced;
317 int err = _dl_catch_error (&objname, &errstring, &malloced,
318 openaux, &args);
320 if (__glibc_unlikely (errstring != NULL))
322 if (d->d_tag == DT_AUXILIARY)
324 /* We are not interested in the error message. */
325 assert (errstring != NULL);
326 if (malloced)
327 free ((char *) errstring);
329 /* Simply ignore this error and continue the work. */
330 continue;
332 else
335 char *new_errstring = strdupa (errstring);
336 objname = strdupa (objname);
337 if (malloced)
338 free ((char *) errstring);
339 errstring = new_errstring;
341 if (err)
342 errno_reason = err;
343 else
344 errno_reason = -1;
345 goto out;
349 /* The auxiliary object is actually available.
350 Incorporate the map in all the lists. */
352 /* Allocate new entry. This always has to be done. */
353 newp = alloca (sizeof (struct list));
355 /* We want to insert the new map before the current one,
356 but we have no back links. So we copy the contents of
357 the current entry over. Note that ORIG and NEWP now
358 have switched their meanings. */
359 memcpy (newp, orig, sizeof (*newp));
361 /* Initialize new entry. */
362 orig->done = 0;
363 orig->map = args.aux;
365 /* Remember this dependency. */
366 if (needed != NULL)
367 needed[nneeded++] = args.aux;
369 /* We must handle two situations here: the map is new,
370 so we must add it in all three lists. If the map
371 is already known, we have two further possibilities:
372 - if the object is before the current map in the
373 search list, we do nothing. It is already found
374 early
375 - if the object is after the current one, we must
376 move it just before the current map to make sure
377 the symbols are found early enough
379 if (args.aux->l_reserved)
381 /* The object is already somewhere in the list.
382 Locate it first. */
383 struct list *late;
385 /* This object is already in the search list we
386 are building. Don't add a duplicate pointer.
387 Just added by _dl_map_object. */
388 for (late = newp; late->next != NULL; late = late->next)
389 if (late->next->map == args.aux)
390 break;
392 if (late->next != NULL)
394 /* The object is somewhere behind the current
395 position in the search path. We have to
396 move it to this earlier position. */
397 orig->next = newp;
399 /* Now remove the later entry from the list
400 and adjust the tail pointer. */
401 if (tail == late->next)
402 tail = late;
403 late->next = late->next->next;
405 /* We must move the object earlier in the chain. */
406 if (args.aux->l_prev != NULL)
407 args.aux->l_prev->l_next = args.aux->l_next;
408 if (args.aux->l_next != NULL)
409 args.aux->l_next->l_prev = args.aux->l_prev;
411 args.aux->l_prev = newp->map->l_prev;
412 newp->map->l_prev = args.aux;
413 if (args.aux->l_prev != NULL)
414 args.aux->l_prev->l_next = args.aux;
415 args.aux->l_next = newp->map;
417 else
419 /* The object must be somewhere earlier in the
420 list. Undo to the current list element what
421 we did above. */
422 memcpy (orig, newp, sizeof (*newp));
423 continue;
426 else
428 /* This is easy. We just add the symbol right here. */
429 orig->next = newp;
430 ++nlist;
431 /* Set the mark bit that says it's already in the list. */
432 args.aux->l_reserved = 1;
434 /* The only problem is that in the double linked
435 list of all objects we don't have this new
436 object at the correct place. Correct this here. */
437 if (args.aux->l_prev)
438 args.aux->l_prev->l_next = args.aux->l_next;
439 if (args.aux->l_next)
440 args.aux->l_next->l_prev = args.aux->l_prev;
442 args.aux->l_prev = newp->map->l_prev;
443 newp->map->l_prev = args.aux;
444 if (args.aux->l_prev != NULL)
445 args.aux->l_prev->l_next = args.aux;
446 args.aux->l_next = newp->map;
449 /* Move the tail pointer if necessary. */
450 if (orig == tail)
451 tail = newp;
453 /* Move on the insert point. */
454 orig = newp;
458 /* Terminate the list of dependencies and store the array address. */
459 if (needed != NULL)
461 needed[nneeded++] = NULL;
463 struct link_map **l_initfini = (struct link_map **)
464 malloc ((2 * nneeded + 1) * sizeof needed[0]);
465 if (l_initfini == NULL)
466 _dl_signal_error (ENOMEM, map->l_name, NULL,
467 N_("cannot allocate dependency list"));
468 l_initfini[0] = l;
469 memcpy (&l_initfini[1], needed, nneeded * sizeof needed[0]);
470 memcpy (&l_initfini[nneeded + 1], l_initfini,
471 nneeded * sizeof needed[0]);
472 atomic_write_barrier ();
473 l->l_initfini = l_initfini;
474 l->l_free_initfini = 1;
477 /* If we have no auxiliary objects just go on to the next map. */
478 if (runp->done)
480 runp = runp->next;
481 while (runp != NULL && runp->done);
484 out:
485 if (errno == 0 && errno_saved != 0)
486 __set_errno (errno_saved);
488 struct link_map **old_l_initfini = NULL;
489 if (map->l_initfini != NULL && map->l_type == lt_loaded)
491 /* This object was previously loaded as a dependency and we have
492 a separate l_initfini list. We don't need it anymore. */
493 assert (map->l_searchlist.r_list == NULL);
494 old_l_initfini = map->l_initfini;
497 /* Store the search list we built in the object. It will be used for
498 searches in the scope of this object. */
499 struct link_map **l_initfini =
500 (struct link_map **) malloc ((2 * nlist + 1)
501 * sizeof (struct link_map *));
502 if (l_initfini == NULL)
503 _dl_signal_error (ENOMEM, map->l_name, NULL,
504 N_("cannot allocate symbol search list"));
507 map->l_searchlist.r_list = &l_initfini[nlist + 1];
508 map->l_searchlist.r_nlist = nlist;
510 for (nlist = 0, runp = known; runp; runp = runp->next)
512 if (__builtin_expect (trace_mode, 0) && runp->map->l_faked)
513 /* This can happen when we trace the loading. */
514 --map->l_searchlist.r_nlist;
515 else
516 map->l_searchlist.r_list[nlist++] = runp->map;
518 /* Now clear all the mark bits we set in the objects on the search list
519 to avoid duplicates, so the next call starts fresh. */
520 runp->map->l_reserved = 0;
523 if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK, 0) != 0
524 && map == GL(dl_ns)[LM_ID_BASE]._ns_loaded)
526 /* If we are to compute conflicts, we have to build local scope
527 for each library, not just the ultimate loader. */
528 for (i = 0; i < nlist; ++i)
530 struct link_map *l = map->l_searchlist.r_list[i];
531 unsigned int j, cnt;
533 /* The local scope has been already computed. */
534 if (l == map
535 || (l->l_local_scope[0]
536 && l->l_local_scope[0]->r_nlist) != 0)
537 continue;
539 if (l->l_info[AUXTAG] || l->l_info[FILTERTAG])
541 /* As current DT_AUXILIARY/DT_FILTER implementation needs to be
542 rewritten, no need to bother with prelinking the old
543 implementation. */
544 _dl_signal_error (EINVAL, l->l_name, NULL, N_("\
545 Filters not supported with LD_TRACE_PRELINKING"));
548 cnt = _dl_build_local_scope (l_initfini, l);
549 assert (cnt <= nlist);
550 for (j = 0; j < cnt; j++)
552 l_initfini[j]->l_reserved = 0;
553 if (j && __builtin_expect (l_initfini[j]->l_info[DT_SYMBOLIC]
554 != NULL, 0))
555 l->l_symbolic_in_local_scope = true;
558 l->l_local_scope[0] =
559 (struct r_scope_elem *) malloc (sizeof (struct r_scope_elem)
560 + (cnt
561 * sizeof (struct link_map *)));
562 if (l->l_local_scope[0] == NULL)
563 _dl_signal_error (ENOMEM, map->l_name, NULL,
564 N_("cannot allocate symbol search list"));
565 l->l_local_scope[0]->r_nlist = cnt;
566 l->l_local_scope[0]->r_list =
567 (struct link_map **) (l->l_local_scope[0] + 1);
568 memcpy (l->l_local_scope[0]->r_list, l_initfini,
569 cnt * sizeof (struct link_map *));
573 /* Maybe we can remove some relocation dependencies now. */
574 assert (map->l_searchlist.r_list[0] == map);
575 struct link_map_reldeps *l_reldeps = NULL;
576 if (map->l_reldeps != NULL)
578 for (i = 1; i < nlist; ++i)
579 map->l_searchlist.r_list[i]->l_reserved = 1;
581 struct link_map **list = &map->l_reldeps->list[0];
582 for (i = 0; i < map->l_reldeps->act; ++i)
583 if (list[i]->l_reserved)
585 /* Need to allocate new array of relocation dependencies. */
586 l_reldeps = malloc (sizeof (*l_reldeps)
587 + map->l_reldepsmax
588 * sizeof (struct link_map *));
589 if (l_reldeps == NULL)
590 /* Bad luck, keep the reldeps duplicated between
591 map->l_reldeps->list and map->l_initfini lists. */
593 else
595 unsigned int j = i;
596 memcpy (&l_reldeps->list[0], &list[0],
597 i * sizeof (struct link_map *));
598 for (i = i + 1; i < map->l_reldeps->act; ++i)
599 if (!list[i]->l_reserved)
600 l_reldeps->list[j++] = list[i];
601 l_reldeps->act = j;
605 for (i = 1; i < nlist; ++i)
606 map->l_searchlist.r_list[i]->l_reserved = 0;
609 /* Sort the initializer list to take dependencies into account. The binary
610 itself will always be initialize last. */
611 memcpy (l_initfini, map->l_searchlist.r_list,
612 nlist * sizeof (struct link_map *));
613 if (__glibc_likely (nlist > 1))
615 /* We can skip looking for the binary itself which is at the front
616 of the search list. */
617 i = 1;
618 uint16_t seen[nlist];
619 memset (seen, 0, nlist * sizeof (seen[0]));
620 while (1)
622 /* Keep track of which object we looked at this round. */
623 ++seen[i];
624 struct link_map *thisp = l_initfini[i];
626 /* Find the last object in the list for which the current one is
627 a dependency and move the current object behind the object
628 with the dependency. */
629 unsigned int k = nlist - 1;
630 while (k > i)
632 struct link_map **runp = l_initfini[k]->l_initfini;
633 if (runp != NULL)
634 /* Look through the dependencies of the object. */
635 while (*runp != NULL)
636 if (__glibc_unlikely (*runp++ == thisp))
638 /* Move the current object to the back past the last
639 object with it as the dependency. */
640 memmove (&l_initfini[i], &l_initfini[i + 1],
641 (k - i) * sizeof (l_initfini[0]));
642 l_initfini[k] = thisp;
644 if (seen[i + 1] > nlist - i)
646 ++i;
647 goto next_clear;
650 uint16_t this_seen = seen[i];
651 memmove (&seen[i], &seen[i + 1],
652 (k - i) * sizeof (seen[0]));
653 seen[k] = this_seen;
655 goto next;
658 --k;
661 if (++i == nlist)
662 break;
663 next_clear:
664 memset (&seen[i], 0, (nlist - i) * sizeof (seen[0]));
666 next:;
670 /* Terminate the list of dependencies. */
671 l_initfini[nlist] = NULL;
672 atomic_write_barrier ();
673 map->l_initfini = l_initfini;
674 map->l_free_initfini = 1;
675 if (l_reldeps != NULL)
677 atomic_write_barrier ();
678 void *old_l_reldeps = map->l_reldeps;
679 map->l_reldeps = l_reldeps;
680 _dl_scope_free (old_l_reldeps);
682 if (old_l_initfini != NULL)
683 _dl_scope_free (old_l_initfini);
685 if (errno_reason)
686 _dl_signal_error (errno_reason == -1 ? 0 : errno_reason, objname,
687 NULL, errstring);