Add new parameter to _dl_map_object calls.
[kopensolaris-gnu/glibc.git] / elf / dl-deps.c
1 /* Load the dependencies of a mapped object.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
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
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.
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
13    Library General Public License for more details.
14
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.  */
19
20 #include <assert.h>
21 #include <dlfcn.h>
22 #include <errno.h>
23 #include <libintl.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <sys/param.h>
28 #include <ldsodefs.h>
29
30 #include <dl-dst.h>
31
32 /* Whether an shared object references one or more auxiliary objects
33    is signaled by the AUXTAG entry in l_info.  */
34 #define AUXTAG  (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
35                  + DT_EXTRATAGIDX (DT_AUXILIARY))
36 /* Whether an shared object references one or more auxiliary objects
37    is signaled by the AUXTAG entry in l_info.  */
38 #define FILTERTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
39                    + DT_EXTRATAGIDX (DT_FILTER))
40
41 /* This is zero at program start to signal that the global scope map is
42    allocated by rtld.  Later it keeps the size of the map.  It might be
43    reset if in _dl_close if the last global object is removed.  */
44 size_t _dl_global_scope_alloc;
45
46 extern size_t _dl_platformlen;
47
48 /* When loading auxiliary objects we must ignore errors.  It's ok if
49    an object is missing.  */
50 struct openaux_args
51   {
52     /* The arguments to openaux.  */
53     struct link_map *map;
54     int trace_mode;
55     const char *strtab;
56     const char *name;
57
58     /* The return value of openaux.  */
59     struct link_map *aux;
60   };
61
62 static void
63 openaux (void *a)
64 {
65   struct openaux_args *args = (struct openaux_args *) a;
66
67   args->aux = _dl_map_object (args->map, args->name, 0,
68                               (args->map->l_type == lt_executable
69                                ? lt_library : args->map->l_type),
70                               args->trace_mode, 0);
71 }
72
73
74
75 /* We use a very special kind of list to track the two kinds paths
76    through the list of loaded shared objects.  We have to
77
78    - produce a flat list with unique members of all involved objects
79
80    - produce a flat list of all shared objects.
81 */
82 struct list
83   {
84     int done;                   /* Nonzero if this map was processed.  */
85     struct link_map *map;       /* The data.  */
86
87     struct list *unique;        /* Elements for normal list.  */
88     struct list *dup;           /* Elements in complete list.  */
89   };
90
91
92 /* Macro to expand DST.  It is an macro since we use `alloca'.  */
93 #define expand_dst(l, str, fatal) \
94   ({                                                                          \
95     const char *__str = (str);                                                \
96     const char *__result = __str;                                             \
97     size_t __cnt = DL_DST_COUNT(__str, 0);                                    \
98                                                                               \
99     if (__cnt != 0)                                                           \
100       {                                                                       \
101         char *__newp;                                                         \
102                                                                               \
103         /* DST must not appear in SUID/SGID programs.  */                     \
104         if (__libc_enable_secure)                                             \
105           _dl_signal_error (0, __str,                                         \
106                             N_("DST not allowed in SUID/SGID programs"));     \
107                                                                               \
108         __newp = (char *) alloca (DL_DST_REQUIRED (l, __str, strlen (__str),  \
109                                                    __cnt));                   \
110                                                                               \
111         __result = DL_DST_SUBSTITUTE (l, __str, __newp, 0);                   \
112                                                                               \
113         if (*__result == '\0')                                                \
114           {                                                                   \
115             /* The replacement for the DST is not known.  We can't            \
116                processed.  */                                                 \
117             if (fatal)                                                        \
118               _dl_signal_error (0, __str, N_("\
119 empty dynamics string token substitution"));                                  \
120             else                                                              \
121               {                                                               \
122                 /* This is for DT_AUXILIARY.  */                              \
123                 if (__builtin_expect (_dl_debug_libs, 0))                     \
124                   _dl_debug_message (1, "cannot load auxiliary `", __str,     \
125                                      "' because of empty dynamic string"      \
126                                      " token substitution\n", NULL);          \
127                 continue;                                                     \
128               }                                                               \
129           }                                                                   \
130       }                                                                       \
131                                                                               \
132     __result; })
133
134
135 void
136 internal_function
137 _dl_map_object_deps (struct link_map *map,
138                      struct link_map **preloads, unsigned int npreloads,
139                      int trace_mode)
140 {
141   struct list known[1 + npreloads + 1];
142   struct list *runp, *utail, *dtail;
143   unsigned int nlist, nduplist, i;
144
145   inline void preload (struct link_map *map)
146     {
147       known[nlist].done = 0;
148       known[nlist].map = map;
149
150       known[nlist].unique = &known[nlist + 1];
151       known[nlist].dup = &known[nlist + 1];
152
153       ++nlist;
154       /* We use `l_reserved' as a mark bit to detect objects we have
155          already put in the search list and avoid adding duplicate
156          elements later in the list.  */
157       map->l_reserved = 1;
158     }
159
160   /* No loaded object so far.  */
161   nlist = 0;
162
163   /* First load MAP itself.  */
164   preload (map);
165
166   /* Add the preloaded items after MAP but before any of its dependencies.  */
167   for (i = 0; i < npreloads; ++i)
168     preload (preloads[i]);
169
170   /* Terminate the lists.  */
171   known[nlist - 1].unique = NULL;
172   known[nlist - 1].dup = NULL;
173
174   /* Pointer to last unique object.  */
175   utail = &known[nlist - 1];
176   /* Pointer to last loaded object.  */
177   dtail = &known[nlist - 1];
178
179   /* Until now we have the same number of libraries in the normal and
180      the list with duplicates.  */
181   nduplist = nlist;
182
183   /* Process each element of the search list, loading each of its
184      auxiliary objects and immediate dependencies.  Auxiliary objects
185      will be added in the list before the object itself and
186      dependencies will be appended to the list as we step through it.
187      This produces a flat, ordered list that represents a
188      breadth-first search of the dependency tree.
189
190      The whole process is complicated by the fact that we better
191      should use alloca for the temporary list elements.  But using
192      alloca means we cannot use recursive function calls.  */
193   for (runp = known; runp; )
194     {
195       struct link_map *l = runp->map;
196       struct link_map **needed = NULL;
197       unsigned int nneeded = 0;
198
199       /* Unless otherwise stated, this object is handled.  */
200       runp->done = 1;
201
202       /* Allocate a temporary record to contain the references to the
203          dependencies of this object.  */
204       if (l->l_searchlist.r_list == NULL && l != map && l->l_ldnum > 0)
205         needed = (struct link_map **) alloca (l->l_ldnum
206                                               * sizeof (struct link_map *));
207
208       if (l->l_info[DT_NEEDED] || l->l_info[AUXTAG] || l->l_info[FILTERTAG])
209         {
210           const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
211           struct openaux_args args;
212           struct list *orig;
213           const ElfW(Dyn) *d;
214
215           args.strtab = strtab;
216           args.map = l;
217           args.trace_mode = trace_mode;
218           orig = runp;
219
220           for (d = l->l_ld; d->d_tag != DT_NULL; ++d)
221             if (__builtin_expect (d->d_tag, DT_NEEDED) == DT_NEEDED)
222               {
223                 /* Map in the needed object.  */
224                 struct link_map *dep;
225                 /* Allocate new entry.  */
226                 struct list *newp;
227                 /* Object name.  */
228                 const char *name;
229
230                 /* Recognize DSTs.  */
231                 name = expand_dst (l, strtab + d->d_un.d_val, 0);
232
233                 dep = _dl_map_object (l, name, 0,
234                                       l->l_type == lt_executable ? lt_library :
235                                       l->l_type, trace_mode, 0);
236
237                 /* Add it in any case to the duplicate list.  */
238                 newp = alloca (sizeof (struct list));
239                 newp->map = dep;
240                 newp->dup = NULL;
241                 dtail->dup = newp;
242                 dtail = newp;
243                 ++nduplist;
244
245                 if (dep->l_reserved)
246                   /* This object is already in the search list we are
247                      building.  Don't add a duplicate pointer.
248                      Release the reference just added by
249                      _dl_map_object.  */
250                   --dep->l_opencount;
251                 else
252                   {
253                     /* Append DEP to the unique list.  */
254                     newp->done = 0;
255                     newp->unique = NULL;
256                     utail->unique = newp;
257                     utail = newp;
258                     ++nlist;
259                     /* Set the mark bit that says it's already in the list.  */
260                     dep->l_reserved = 1;
261                   }
262
263                 /* Remember this dependency.  */
264                 if (needed != NULL)
265                   needed[nneeded++] = dep;
266               }
267             else if (d->d_tag == DT_AUXILIARY || d->d_tag == DT_FILTER)
268               {
269                 const char *objname;
270                 const char *errstring;
271                 struct list *newp;
272                 /* Object name.  */
273                 const char *name;
274
275                 /* Recognize DSTs.  */
276                 name = expand_dst (l, strtab + d->d_un.d_val,
277                                    d->d_tag == DT_AUXILIARY);
278
279                 if (d->d_tag == DT_AUXILIARY)
280                   {
281                     /* Store the tag in the argument structure.  */
282                     args.name = name;
283
284                     /* Say that we are about to load an auxiliary library.  */
285                     if (__builtin_expect (_dl_debug_libs, 0))
286                       _dl_debug_message (1, "load auxiliary object=",
287                                          name, " requested by file=",
288                                          l->l_name[0]
289                                          ? l->l_name : _dl_argv[0],
290                                          "\n", NULL);
291
292                     /* We must be prepared that the addressed shared
293                        object is not available.  */
294                     if (_dl_catch_error (&objname, &errstring, openaux, &args))
295                       {
296                         /* We are not interested in the error message.  */
297                         assert (errstring != NULL);
298                         if (errstring != _dl_out_of_memory)
299                           free ((char *) errstring);
300
301                         /* Simply ignore this error and continue the work.  */
302                         continue;
303                       }
304                   }
305                 else
306                   {
307                     /* Say that we are about to load an auxiliary library.  */
308                     if (__builtin_expect (_dl_debug_libs, 0))
309                       _dl_debug_message (1, "load filtered object=", name,
310                                          " requested by file=",
311                                          l->l_name[0]
312                                          ? l->l_name : _dl_argv[0],
313                                          "\n", NULL);
314
315                     /* For filter objects the dependency must be available.  */
316                     args.aux = _dl_map_object (l, name, 0,
317                                                (l->l_type == lt_executable
318                                                 ? lt_library : l->l_type),
319                                                trace_mode, 0);
320                   }
321
322                 /* The auxiliary object is actually available.
323                    Incorporate the map in all the lists.  */
324
325                 /* Allocate new entry.  This always has to be done.  */
326                 newp = alloca (sizeof (struct list));
327
328                 /* We want to insert the new map before the current one,
329                    but we have no back links.  So we copy the contents of
330                    the current entry over.  Note that ORIG and NEWP now
331                    have switched their meanings.  */
332                 orig->dup = memcpy (newp, orig, sizeof (*newp));
333
334                 /* Initialize new entry.  */
335                 orig->done = 0;
336                 orig->map = args.aux;
337
338                 /* Remember this dependency.  */
339                 if (needed != NULL)
340                   needed[nneeded++] = args.aux;
341
342                 /* We must handle two situations here: the map is new,
343                    so we must add it in all three lists.  If the map
344                    is already known, we have two further possibilities:
345                    - if the object is before the current map in the
346                    search list, we do nothing.  It is already found
347                    early
348                    - if the object is after the current one, we must
349                    move it just before the current map to make sure
350                    the symbols are found early enough
351                 */
352                 if (args.aux->l_reserved)
353                   {
354                     /* The object is already somewhere in the list.
355                        Locate it first.  */
356                     struct list *late;
357
358                     /* This object is already in the search list we
359                        are building.  Don't add a duplicate pointer.
360                        Release the reference just added by
361                        _dl_map_object.  */
362                     --args.aux->l_opencount;
363
364                     for (late = newp; late->unique; late = late->unique)
365                       if (late->unique->map == args.aux)
366                         break;
367
368                     if (late->unique)
369                       {
370                         /* The object is somewhere behind the current
371                            position in the search path.  We have to
372                            move it to this earlier position.  */
373                         orig->unique = newp;
374
375                         /* Now remove the later entry from the unique list
376                            and adjust the tail pointer.  */
377                         if (utail == late->unique)
378                           utail = late;
379                         late->unique = late->unique->unique;
380
381                         /* We must move the object earlier in the chain.  */
382                         if (args.aux->l_prev)
383                           args.aux->l_prev->l_next = args.aux->l_next;
384                         if (args.aux->l_next)
385                           args.aux->l_next->l_prev = args.aux->l_prev;
386
387                         args.aux->l_prev = newp->map->l_prev;
388                         newp->map->l_prev = args.aux;
389                         if (args.aux->l_prev != NULL)
390                           args.aux->l_prev->l_next = args.aux;
391                         args.aux->l_next = newp->map;
392                       }
393                     else
394                       {
395                         /* The object must be somewhere earlier in the
396                            list.  That's good, we only have to insert
397                            an entry for the duplicate list.  */
398                         orig->unique = NULL;    /* Never used.  */
399
400                         /* Now we have a problem.  The element
401                            pointing to ORIG in the unique list must
402                            point to NEWP now.  This is the only place
403                            where we need this backreference and this
404                            situation is really not that frequent.  So
405                            we don't use a double-linked list but
406                            instead search for the preceding element.  */
407                         late = known;
408                         while (late->unique != orig)
409                           late = late->unique;
410                         late->unique = newp;
411                       }
412                   }
413                 else
414                   {
415                     /* This is easy.  We just add the symbol right here.  */
416                     orig->unique = newp;
417                     ++nlist;
418                     /* Set the mark bit that says it's already in the list.  */
419                     args.aux->l_reserved = 1;
420
421                     /* The only problem is that in the double linked
422                        list of all objects we don't have this new
423                        object at the correct place.  Correct this here.  */
424                     if (args.aux->l_prev)
425                       args.aux->l_prev->l_next = args.aux->l_next;
426                     if (args.aux->l_next)
427                       args.aux->l_next->l_prev = args.aux->l_prev;
428
429                     args.aux->l_prev = newp->map->l_prev;
430                     newp->map->l_prev = args.aux;
431                     if (args.aux->l_prev != NULL)
432                       args.aux->l_prev->l_next = args.aux;
433                     args.aux->l_next = newp->map;
434                   }
435
436                 /* Move the tail pointers if necessary.  */
437                 if (orig == utail)
438                   utail = newp;
439                 if (orig == dtail)
440                   dtail = newp;
441
442                 /* Move on the insert point.  */
443                 orig = newp;
444
445                 /* We always add an entry to the duplicate list.  */
446                 ++nduplist;
447               }
448         }
449
450       /* Terminate the list of dependencies and store the array address.  */
451       if (needed != NULL)
452         {
453           needed[nneeded++] = NULL;
454
455           l->l_initfini = malloc (nneeded * sizeof needed[0]);
456           if (l->l_initfini == NULL)
457             _dl_signal_error (ENOMEM, map->l_name,
458                               N_("cannot allocate dependency list"));
459           memcpy (l->l_initfini, needed, nneeded * sizeof needed[0]);
460         }
461
462       /* If we have no auxiliary objects just go on to the next map.  */
463       if (runp->done)
464         do
465           runp = runp->unique;
466         while (runp != NULL && runp->done);
467     }
468
469   /* Store the search list we built in the object.  It will be used for
470      searches in the scope of this object.  */
471   map->l_searchlist.r_list = malloc ((2 * nlist + 1
472                                       + (nlist == nduplist ? 0 : nduplist))
473                                      * sizeof (struct link_map *));
474   if (map->l_searchlist.r_list == NULL)
475     _dl_signal_error (ENOMEM, map->l_name,
476                       N_("cannot allocate symbol search list"));
477   map->l_searchlist.r_nlist = nlist;
478
479   for (nlist = 0, runp = known; runp; runp = runp->unique)
480     {
481       if (trace_mode && runp->map->l_opencount == 0)
482         /* This can happen when we trace the loading.  */
483         --map->l_searchlist.r_nlist;
484       else
485         map->l_searchlist.r_list[nlist++] = runp->map;
486
487       /* Now clear all the mark bits we set in the objects on the search list
488          to avoid duplicates, so the next call starts fresh.  */
489       runp->map->l_reserved = 0;
490     }
491
492   map->l_searchlist.r_nduplist = nduplist;
493   if (nlist == nduplist)
494     map->l_searchlist.r_duplist = map->l_searchlist.r_list;
495   else
496     {
497       unsigned int cnt;
498
499       map->l_searchlist.r_duplist = map->l_searchlist.r_list + nlist;
500
501       for (cnt = 0, runp = known; runp; runp = runp->dup)
502         if (trace_mode && runp->map->l_opencount == 0)
503           /* This can happen when we trace the loading.  */
504           --map->l_searchlist.r_nduplist;
505         else
506           map->l_searchlist.r_duplist[cnt++] = runp->map;
507     }
508
509   /* Now determine the order in which the initialization has to happen.  */
510   map->l_initfini =
511     (struct link_map **) memcpy (map->l_searchlist.r_duplist + nduplist,
512                                  map->l_searchlist.r_list,
513                                  nlist * sizeof (struct link_map *));
514   /* We can skip looking for the binary itself which is at the front
515      of the search list.  Look through the list backward so that circular
516      dependencies are not changing the order.  */
517   for (i = 1; i < nlist; ++i)
518     {
519       struct link_map *l = map->l_searchlist.r_list[i];
520       unsigned int j;
521       unsigned int k;
522
523       /* Find the place in the initfini list where the map is currently
524          located.  */
525       for (j = 1; map->l_initfini[j] != l; ++j)
526         ;
527
528       /* Find all object for which the current one is a dependency and
529          move the found object (if necessary) in front.  */
530       for (k = j + 1; k < nlist; ++k)
531         {
532           struct link_map **runp;
533
534           runp = map->l_initfini[k]->l_initfini;
535           if (runp != NULL)
536             {
537               while (*runp != NULL)
538                 if (*runp == l)
539                   {
540                     struct link_map *here = map->l_initfini[k];
541
542                     /* Move it now.  */
543                     memmove (&map->l_initfini[j] + 1,
544                              &map->l_initfini[j],
545                              (k - j) * sizeof (struct link_map *));
546                     map->l_initfini[j] = here;
547
548                     break;
549                   }
550                 else
551                   ++runp;
552             }
553         }
554     }
555   /* Terminate the list of dependencies.  */
556   map->l_initfini[nlist] = NULL;
557 }