lh | 9ed821d | 2023-04-07 01:36:19 -0700 | [diff] [blame^] | 1 | /* Load the dependencies of a mapped object. |
| 2 | Copyright (C) 1996-2015 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 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. |
| 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 | Lesser General Public License for more details. |
| 14 | |
| 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/>. */ |
| 18 | |
| 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> |
| 30 | |
| 31 | #include <dl-dst.h> |
| 32 | |
| 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)) |
| 41 | |
| 42 | |
| 43 | /* When loading auxiliary objects we must ignore errors. It's ok if |
| 44 | an object is missing. */ |
| 45 | struct openaux_args |
| 46 | { |
| 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; |
| 53 | |
| 54 | /* The return value of openaux. */ |
| 55 | struct link_map *aux; |
| 56 | }; |
| 57 | |
| 58 | static void |
| 59 | openaux (void *a) |
| 60 | { |
| 61 | struct openaux_args *args = (struct openaux_args *) a; |
| 62 | |
| 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); |
| 68 | } |
| 69 | |
| 70 | static ptrdiff_t |
| 71 | internal_function |
| 72 | _dl_build_local_scope (struct link_map **list, struct link_map *map) |
| 73 | { |
| 74 | struct link_map **p = list; |
| 75 | struct link_map **q; |
| 76 | |
| 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; |
| 84 | } |
| 85 | |
| 86 | |
| 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. |
| 90 | */ |
| 91 | struct list |
| 92 | { |
| 93 | int done; /* Nonzero if this map was processed. */ |
| 94 | struct link_map *map; /* The data. */ |
| 95 | struct list *next; /* Elements for normal list. */ |
| 96 | }; |
| 97 | |
| 98 | |
| 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); \ |
| 105 | \ |
| 106 | if (__dst_cnt != 0) \ |
| 107 | { \ |
| 108 | char *__newp; \ |
| 109 | \ |
| 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")); \ |
| 114 | \ |
| 115 | __newp = (char *) alloca (DL_DST_REQUIRED (l, __str, strlen (__str), \ |
| 116 | __dst_cnt)); \ |
| 117 | \ |
| 118 | __result = _dl_dst_substitute (l, __str, __newp, 0); \ |
| 119 | \ |
| 120 | if (*__result == '\0') \ |
| 121 | { \ |
| 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 \ |
| 128 | { \ |
| 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; \ |
| 135 | } \ |
| 136 | } \ |
| 137 | } \ |
| 138 | \ |
| 139 | __result; }) |
| 140 | |
| 141 | static void |
| 142 | preload (struct list *known, unsigned int *nlist, struct link_map *map) |
| 143 | { |
| 144 | known[*nlist].done = 0; |
| 145 | known[*nlist].map = map; |
| 146 | known[*nlist].next = &known[*nlist + 1]; |
| 147 | |
| 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; |
| 153 | } |
| 154 | |
| 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) |
| 160 | { |
| 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; |
| 170 | |
| 171 | /* No loaded object so far. */ |
| 172 | nlist = 0; |
| 173 | |
| 174 | /* First load MAP itself. */ |
| 175 | preload (known, &nlist, map); |
| 176 | |
| 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]); |
| 180 | |
| 181 | /* Terminate the lists. */ |
| 182 | known[nlist - 1].next = NULL; |
| 183 | |
| 184 | /* Pointer to last unique object. */ |
| 185 | tail = &known[nlist - 1]; |
| 186 | |
| 187 | /* No alloca'd space yet. */ |
| 188 | struct link_map **needed_space = NULL; |
| 189 | size_t needed_space_bytes = 0; |
| 190 | |
| 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. |
| 197 | |
| 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; ) |
| 207 | { |
| 208 | struct link_map *l = runp->map; |
| 209 | struct link_map **needed = NULL; |
| 210 | unsigned int nneeded = 0; |
| 211 | |
| 212 | /* Unless otherwise stated, this object is handled. */ |
| 213 | runp->done = 1; |
| 214 | |
| 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) |
| 219 | { |
| 220 | size_t new_size = l->l_ldnum * sizeof (struct link_map *); |
| 221 | |
| 222 | if (new_size > needed_space_bytes) |
| 223 | needed_space |
| 224 | = extend_alloca (needed_space, needed_space_bytes, new_size); |
| 225 | |
| 226 | needed = needed_space; |
| 227 | } |
| 228 | |
| 229 | if (l->l_info[DT_NEEDED] || l->l_info[AUXTAG] || l->l_info[FILTERTAG]) |
| 230 | { |
| 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; |
| 235 | |
| 236 | args.strtab = strtab; |
| 237 | args.map = l; |
| 238 | args.trace_mode = trace_mode; |
| 239 | args.open_mode = open_mode; |
| 240 | orig = runp; |
| 241 | |
| 242 | for (d = l->l_ld; d->d_tag != DT_NULL; ++d) |
| 243 | if (__builtin_expect (d->d_tag, DT_NEEDED) == DT_NEEDED) |
| 244 | { |
| 245 | /* Map in the needed object. */ |
| 246 | struct link_map *dep; |
| 247 | |
| 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; |
| 252 | |
| 253 | bool malloced; |
| 254 | int err = _dl_catch_error (&objname, &errstring, &malloced, |
| 255 | openaux, &args); |
| 256 | if (__glibc_unlikely (errstring != NULL)) |
| 257 | { |
| 258 | char *new_errstring = strdupa (errstring); |
| 259 | objname = strdupa (objname); |
| 260 | if (malloced) |
| 261 | free ((char *) errstring); |
| 262 | errstring = new_errstring; |
| 263 | |
| 264 | if (err) |
| 265 | errno_reason = err; |
| 266 | else |
| 267 | errno_reason = -1; |
| 268 | goto out; |
| 269 | } |
| 270 | else |
| 271 | dep = args.aux; |
| 272 | |
| 273 | if (! dep->l_reserved) |
| 274 | { |
| 275 | /* Allocate new entry. */ |
| 276 | struct list *newp; |
| 277 | |
| 278 | newp = alloca (sizeof (struct list)); |
| 279 | |
| 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; |
| 289 | } |
| 290 | |
| 291 | /* Remember this dependency. */ |
| 292 | if (needed != NULL) |
| 293 | needed[nneeded++] = dep; |
| 294 | } |
| 295 | else if (d->d_tag == DT_AUXILIARY || d->d_tag == DT_FILTER) |
| 296 | { |
| 297 | struct list *newp; |
| 298 | |
| 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; |
| 304 | |
| 305 | /* Say that we are about to load an auxiliary library. */ |
| 306 | if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, |
| 307 | 0)) |
| 308 | _dl_debug_printf ("load auxiliary object=%s" |
| 309 | " requested by file=%s\n", |
| 310 | name, |
| 311 | DSO_FILENAME (l->l_name)); |
| 312 | |
| 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); |
| 319 | |
| 320 | if (__glibc_unlikely (errstring != NULL)) |
| 321 | { |
| 322 | if (d->d_tag == DT_AUXILIARY) |
| 323 | { |
| 324 | /* We are not interested in the error message. */ |
| 325 | assert (errstring != NULL); |
| 326 | if (malloced) |
| 327 | free ((char *) errstring); |
| 328 | |
| 329 | /* Simply ignore this error and continue the work. */ |
| 330 | continue; |
| 331 | } |
| 332 | else |
| 333 | { |
| 334 | |
| 335 | char *new_errstring = strdupa (errstring); |
| 336 | objname = strdupa (objname); |
| 337 | if (malloced) |
| 338 | free ((char *) errstring); |
| 339 | errstring = new_errstring; |
| 340 | |
| 341 | if (err) |
| 342 | errno_reason = err; |
| 343 | else |
| 344 | errno_reason = -1; |
| 345 | goto out; |
| 346 | } |
| 347 | } |
| 348 | |
| 349 | /* The auxiliary object is actually available. |
| 350 | Incorporate the map in all the lists. */ |
| 351 | |
| 352 | /* Allocate new entry. This always has to be done. */ |
| 353 | newp = alloca (sizeof (struct list)); |
| 354 | |
| 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)); |
| 360 | |
| 361 | /* Initialize new entry. */ |
| 362 | orig->done = 0; |
| 363 | orig->map = args.aux; |
| 364 | |
| 365 | /* Remember this dependency. */ |
| 366 | if (needed != NULL) |
| 367 | needed[nneeded++] = args.aux; |
| 368 | |
| 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 |
| 378 | */ |
| 379 | if (args.aux->l_reserved) |
| 380 | { |
| 381 | /* The object is already somewhere in the list. |
| 382 | Locate it first. */ |
| 383 | struct list *late; |
| 384 | |
| 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; |
| 391 | |
| 392 | if (late->next != NULL) |
| 393 | { |
| 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; |
| 398 | |
| 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; |
| 404 | |
| 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; |
| 410 | |
| 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; |
| 416 | } |
| 417 | else |
| 418 | { |
| 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; |
| 424 | } |
| 425 | } |
| 426 | else |
| 427 | { |
| 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; |
| 433 | |
| 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; |
| 441 | |
| 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; |
| 447 | } |
| 448 | |
| 449 | /* Move the tail pointer if necessary. */ |
| 450 | if (orig == tail) |
| 451 | tail = newp; |
| 452 | |
| 453 | /* Move on the insert point. */ |
| 454 | orig = newp; |
| 455 | } |
| 456 | } |
| 457 | |
| 458 | /* Terminate the list of dependencies and store the array address. */ |
| 459 | if (needed != NULL) |
| 460 | { |
| 461 | needed[nneeded++] = NULL; |
| 462 | |
| 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; |
| 475 | } |
| 476 | |
| 477 | /* If we have no auxiliary objects just go on to the next map. */ |
| 478 | if (runp->done) |
| 479 | do |
| 480 | runp = runp->next; |
| 481 | while (runp != NULL && runp->done); |
| 482 | } |
| 483 | |
| 484 | out: |
| 485 | if (errno == 0 && errno_saved != 0) |
| 486 | __set_errno (errno_saved); |
| 487 | |
| 488 | struct link_map **old_l_initfini = NULL; |
| 489 | if (map->l_initfini != NULL && map->l_type == lt_loaded) |
| 490 | { |
| 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; |
| 495 | } |
| 496 | |
| 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")); |
| 505 | |
| 506 | |
| 507 | map->l_searchlist.r_list = &l_initfini[nlist + 1]; |
| 508 | map->l_searchlist.r_nlist = nlist; |
| 509 | |
| 510 | for (nlist = 0, runp = known; runp; runp = runp->next) |
| 511 | { |
| 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; |
| 517 | |
| 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; |
| 521 | } |
| 522 | |
| 523 | if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK, 0) != 0 |
| 524 | && map == GL(dl_ns)[LM_ID_BASE]._ns_loaded) |
| 525 | { |
| 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) |
| 529 | { |
| 530 | struct link_map *l = map->l_searchlist.r_list[i]; |
| 531 | unsigned int j, cnt; |
| 532 | |
| 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; |
| 538 | |
| 539 | if (l->l_info[AUXTAG] || l->l_info[FILTERTAG]) |
| 540 | { |
| 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")); |
| 546 | } |
| 547 | |
| 548 | cnt = _dl_build_local_scope (l_initfini, l); |
| 549 | assert (cnt <= nlist); |
| 550 | for (j = 0; j < cnt; j++) |
| 551 | { |
| 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; |
| 556 | } |
| 557 | |
| 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 *)); |
| 570 | } |
| 571 | } |
| 572 | |
| 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) |
| 577 | { |
| 578 | for (i = 1; i < nlist; ++i) |
| 579 | map->l_searchlist.r_list[i]->l_reserved = 1; |
| 580 | |
| 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) |
| 584 | { |
| 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. */ |
| 592 | ; |
| 593 | else |
| 594 | { |
| 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; |
| 602 | } |
| 603 | } |
| 604 | |
| 605 | for (i = 1; i < nlist; ++i) |
| 606 | map->l_searchlist.r_list[i]->l_reserved = 0; |
| 607 | } |
| 608 | |
| 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)) |
| 614 | { |
| 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) |
| 621 | { |
| 622 | /* Keep track of which object we looked at this round. */ |
| 623 | ++seen[i]; |
| 624 | struct link_map *thisp = l_initfini[i]; |
| 625 | |
| 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) |
| 631 | { |
| 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)) |
| 637 | { |
| 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; |
| 643 | |
| 644 | if (seen[i + 1] > nlist - i) |
| 645 | { |
| 646 | ++i; |
| 647 | goto next_clear; |
| 648 | } |
| 649 | |
| 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; |
| 654 | |
| 655 | goto next; |
| 656 | } |
| 657 | |
| 658 | --k; |
| 659 | } |
| 660 | |
| 661 | if (++i == nlist) |
| 662 | break; |
| 663 | next_clear: |
| 664 | memset (&seen[i], 0, (nlist - i) * sizeof (seen[0])); |
| 665 | |
| 666 | next:; |
| 667 | } |
| 668 | } |
| 669 | |
| 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) |
| 676 | { |
| 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); |
| 681 | } |
| 682 | if (old_l_initfini != NULL) |
| 683 | _dl_scope_free (old_l_initfini); |
| 684 | |
| 685 | if (errno_reason) |
| 686 | _dl_signal_error (errno_reason == -1 ? 0 : errno_reason, objname, |
| 687 | NULL, errstring); |
| 688 | } |