diff options
Diffstat (limited to 'elf')
| -rw-r--r-- | elf/Versions | 2 | ||||
| -rw-r--r-- | elf/dl-close.c | 17 | ||||
| -rw-r--r-- | elf/dl-fini.c | 27 | ||||
| -rw-r--r-- | elf/dl-load.c | 15 | ||||
| -rw-r--r-- | elf/dl-lookup.c | 243 | ||||
| -rw-r--r-- | elf/dl-open.c | 2 | ||||
| -rw-r--r-- | elf/dl-support.c | 10 | ||||
| -rw-r--r-- | elf/link.h | 5 | ||||
| -rw-r--r-- | elf/rtld.c | 10 |
9 files changed, 304 insertions, 27 deletions
diff --git a/elf/Versions b/elf/Versions index 791fcee8c4..26fd7d62ae 100644 --- a/elf/Versions +++ b/elf/Versions @@ -52,7 +52,7 @@ ld.so { _dl_dst_count; _dl_dst_substitute; } GLIBC_2.2 { - _dl_init; + _dl_init; _dl_load_lock; # this is defined in ld.so and overridden by libc _dl_init_first; diff --git a/elf/dl-close.c b/elf/dl-close.c index a30147976d..a58e8f8e5d 100644 --- a/elf/dl-close.c +++ b/elf/dl-close.c @@ -43,8 +43,10 @@ internal_function _dl_close (void *_map) { struct link_map **list; + struct link_map **rellist; struct link_map *map = _map; - unsigned nsearchlist; + unsigned int nsearchlist; + unsigned int nrellist; unsigned int i; if (map->l_opencount == 0) @@ -65,6 +67,9 @@ _dl_close (void *_map) list = map->l_searchlist.r_list; nsearchlist = map->l_searchlist.r_nlist; + rellist = map->l_reldeps; + nrellist = map->l_reldepsact; + /* Call all termination functions at once. */ for (i = 0; i < nsearchlist; ++i) { @@ -192,6 +197,16 @@ _dl_close (void *_map) } } + /* Now we can perhaps also remove the modules for which we had + dependencies because of symbol lookup. */ + if (rellist != NULL) + { + while (nrellist-- > 0) + _dl_close (rellist[nrellist]); + + free (rellist); + } + free (list); if (_dl_global_scope_alloc != 0 diff --git a/elf/dl-fini.c b/elf/dl-fini.c index 61dedd5168..fd22bc0a4d 100644 --- a/elf/dl-fini.c +++ b/elf/dl-fini.c @@ -87,18 +87,41 @@ _dl_fini (void) memmove (&maps[j] + 1, &maps[j], (k - j) * sizeof (struct link_map *)); - maps[j] = here; + maps[j++] = here; break; } else ++runp; } + + if (__builtin_expect (maps[k]->l_reldeps != NULL, 0)) + { + unsigned int m = maps[k]->l_reldepsact; + struct link_map **relmaps = maps[k]->l_reldeps; + + while (m-- > 0) + { + if (relmaps[m] == l) + { + struct link_map *here = maps[k]; + + /* Move it now. */ + memmove (&maps[j] + 1, + &maps[j], + (k - j) * sizeof (struct link_map *)); + maps[j] = here; + + break; + } + + } + } } } /* `maps' now contains the objects in the right order. Now call the - destructors. We have the process this array from the front. */ + destructors. We have to process this array from the front. */ for (i = 0; i < nloaded; ++i) { l = maps[i]; diff --git a/elf/dl-load.c b/elf/dl-load.c index 5d1463b48f..e57de81015 100644 --- a/elf/dl-load.c +++ b/elf/dl-load.c @@ -748,7 +748,7 @@ _dl_map_object_from_fd (const char *name, int fd, char *realname, } /* Print debugging message. */ - if (_dl_debug_files) + if (__builtin_expect (_dl_debug_files, 0)) _dl_debug_message (1, "file=", name, "; generating link map\n", NULL); /* Read the header directly. */ @@ -1046,7 +1046,7 @@ _dl_map_object_from_fd (const char *name, int fd, char *realname, l->l_entry += l->l_addr; - if (_dl_debug_files) + if (__builtin_expect (_dl_debug_files, 0)) { const size_t nibbles = sizeof (void *) * 2; char buf1[nibbles + 1]; @@ -1182,7 +1182,8 @@ open_path (const char *name, size_t namelen, int preloaded, /* If we are debugging the search for libraries print the path now if it hasn't happened now. */ - if (_dl_debug_libs && current_what != this_dir->what) + if (__builtin_expect (_dl_debug_libs, 0) + && current_what != this_dir->what) { current_what = this_dir->what; print_search_path (dirs, current_what, this_dir->where); @@ -1202,7 +1203,7 @@ open_path (const char *name, size_t namelen, int preloaded, - buf); /* Print name we try if this is wanted. */ - if (_dl_debug_libs) + if (__builtin_expect (_dl_debug_libs, 0)) _dl_debug_message (1, " trying file=", buf, "\n", NULL); fd = __open (buf, O_RDONLY); @@ -1316,7 +1317,7 @@ _dl_map_object (struct link_map *loader, const char *name, int preloaded, } /* Display information if we are debugging. */ - if (_dl_debug_files && loader != NULL) + if (__builtin_expect (_dl_debug_files, 0) && loader != NULL) _dl_debug_message (1, "\nfile=", name, "; needed by ", loader->l_name[0] ? loader->l_name : _dl_argv[0], "\n", NULL); @@ -1327,7 +1328,7 @@ _dl_map_object (struct link_map *loader, const char *name, int preloaded, size_t namelen = strlen (name) + 1; - if (_dl_debug_libs) + if (__builtin_expect (_dl_debug_libs, 0)) _dl_debug_message (1, "find library=", name, "; searching\n", NULL); fd = -1; @@ -1411,7 +1412,7 @@ _dl_map_object (struct link_map *loader, const char *name, int preloaded, fd = open_path (name, namelen, preloaded, rtld_search_dirs, &realname); /* Add another newline when we a tracing the library loading. */ - if (_dl_debug_libs) + if (__builtin_expect (_dl_debug_libs, 0)) _dl_debug_message (1, "\n", NULL); } else diff --git a/elf/dl-lookup.c b/elf/dl-lookup.c index 702fd3b824..7ac87702a4 100644 --- a/elf/dl-lookup.c +++ b/elf/dl-lookup.c @@ -18,11 +18,13 @@ Boston, MA 02111-1307, USA. */ #include <alloca.h> +#include <stdlib.h> #include <string.h> #include <unistd.h> #include <ldsodefs.h> #include "dl-hash.h" #include <dl-machine.h> +#include <bits/libc-lock.h> #include <assert.h> @@ -59,6 +61,15 @@ struct sym_val /* Statistics function. */ unsigned long int _dl_num_relocations; +/* During the program run we must not modify the global data of + loaded shared object simultanously in two threads. Therefore we + protect `_dl_open' and `_dl_close' in dl-close.c. + + This must be a recursive lock since the initializer function of + the loaded object might as well require a call to this function. + At this time it is not anymore a problem to modify the tables. */ +__libc_lock_define (extern, _dl_load_lock) + /* We have two different situations when looking up a simple: with or without versioning. gcc is not able to optimize a single function @@ -70,6 +81,105 @@ unsigned long int _dl_num_relocations; #include "do-lookup.h" +/* Add extra dependency on MAP to UNDEF_MAP. */ +static int +add_dependency (struct link_map *undef_map, struct link_map *map) +{ + struct link_map **list; + unsigned act; + unsigned int i; + int result = 0; + + /* Make sure nobody can unload the object while we are at it. */ + __libc_lock_lock (_dl_load_lock); + + /* Determine whether UNDEF_MAP already has a reference to MAP. First + look in the normal dependencies. */ + list = undef_map->l_searchlist.r_list; + act = undef_map->l_searchlist.r_nlist; + + for (i = 0; i < act; ++i) + if (list[i] == map) + break; + + if (__builtin_expect (i, act) == act) + { + /* No normal dependency. See whether we already had to add it + to the special list of dynamic dependencies. */ + list = undef_map->l_reldeps; + act = undef_map->l_reldepsact; + + for (i = 0; i < act; ++i) + if (list[i] == map) + break; + + if (i == act) + { + /* The object is not yet in the dependency list. Before we add + it make sure just one more time the object we are about to + reference is still available. There is a brief period in + which the object could have been removed since we found the + definition. */ + struct link_map *runp = _dl_loaded; + + while (runp != NULL && runp != map) + runp = runp->l_next; + + if (runp != NULL) + { + /* The object is still available. Add the reference now. */ + if (act >= undef_map->l_reldepsmax) + { + /* Allocate more memory for the dependency list. Since + this can never happen during the startup phase we can + use `realloc'. */ + void *newp; + + undef_map->l_reldepsmax += 5; + newp = realloc (undef_map->l_reldeps, + undef_map->l_reldepsmax); + + if (__builtin_expect (newp != NULL, 1)) + undef_map->l_reldeps = (struct link_map **) newp; + else + /* Correct the addition. */ + undef_map->l_reldepsmax -= 5; + } + + /* If we didn't manage to allocate memory for the list this + is no fatal mistake. We simply increment the use counter + of the referenced object and don't record the dependencies. + This means this increment can never be reverted and the + object will never be unloaded. This is semantically the + correct behaviour. */ + if (act < undef_map->l_reldepsmax) + undef_map->l_reldeps[undef_map->l_reldepsact++] = map; + + /* And increment the counter in the referenced object. */ + ++map->l_opencount; + + /* Display information if we are debugging. */ + if (__builtin_expect (_dl_debug_files, 0)) + _dl_debug_message (1, "\nfile=", + map->l_name[0] ? map->l_name : _dl_argv[0], + "; needed by ", + undef_map->l_name[0] + ? undef_map->l_name : _dl_argv[0], + " (relocation dependency)\n\n", NULL); + } + else + /* Whoa, that was bad luck. We have to search again. */ + result = -1; + } + } + + /* Release the lock. */ + __libc_lock_unlock (_dl_load_lock); + + return result; +} + + /* Search loaded objects' symbol tables for a definition of the symbol UNDEF_NAME. */ @@ -90,7 +200,24 @@ _dl_lookup_symbol (const char *undef_name, struct link_map *undef_map, for (scope = symbol_scope; *scope; ++scope) if (do_lookup (undef_name, undef_map, hash, *ref, ¤t_value, *scope, 0, NULL, reloc_type)) - break; + { + /* We have to check whether this would bind UNDEF_MAP to an object + in the global scope which was dynamically loaded. In this case + we have to prevent the latter from being unloaded unless the + UNDEF_MAP object is also unloaded. */ + if (current_value.m->l_global + && (__builtin_expect (current_value.m->l_type, lt_library) + == lt_loaded) + && undef_map != current_value.m + /* Add UNDEF_MAP to the dependencies. */ + && add_dependency (undef_map, current_value.m) < 0) + /* Something went wrong. Perhaps the object we tried to reference + was just removed. Try finding another definition. */ + return _dl_lookup_symbol (undef_name, undef_map, ref, symbol_scope, + reloc_type); + + break; + } if (current_value.s == NULL) { @@ -104,7 +231,7 @@ _dl_lookup_symbol (const char *undef_name, struct link_map *undef_map, return 0; } - if (_dl_debug_bindings) + if (__builtin_expect (_dl_debug_bindings, 0)) _dl_debug_message (1, "binding file ", (reference_name && reference_name[0] ? reference_name @@ -143,13 +270,47 @@ _dl_lookup_symbol_skip (const char *undef_name, for (i = 0; (*scope)->r_duplist[i] != skip_map; ++i) assert (i < (*scope)->r_nduplist); - if (i >= (*scope)->r_nlist - || ! do_lookup (undef_name, undef_map, hash, *ref, ¤t_value, - *scope, i, skip_map, 0)) + if (i < (*scope)->r_nlist + && do_lookup (undef_name, undef_map, hash, *ref, ¤t_value, + *scope, i, skip_map, 0)) + { + /* We have to check whether this would bind UNDEF_MAP to an object + in the global scope which was dynamically loaded. In this case + we have to prevent the latter from being unloaded unless the + UNDEF_MAP object is also unloaded. */ + if (current_value.m->l_global + && (__builtin_expect (current_value.m->l_type, lt_library) + == lt_loaded) + && undef_map != current_value.m + /* Add UNDEF_MAP to the dependencies. */ + && add_dependency (undef_map, current_value.m) < 0) + /* Something went wrong. Perhaps the object we tried to reference + was just removed. Try finding another definition. */ + return _dl_lookup_symbol_skip (undef_name, undef_map, ref, + symbol_scope, skip_map); + } + else while (*++scope) if (do_lookup (undef_name, undef_map, hash, *ref, ¤t_value, *scope, 0, skip_map, 0)) - break; + { + /* We have to check whether this would bind UNDEF_MAP to an object + in the global scope which was dynamically loaded. In this case + we have to prevent the latter from being unloaded unless the + UNDEF_MAP object is also unloaded. */ + if (current_value.m->l_global + && (__builtin_expect (current_value.m->l_type, lt_library) + == lt_loaded) + && undef_map != current_value.m + /* Add UNDEF_MAP to the dependencies. */ + && add_dependency (undef_map, current_value.m) < 0) + /* Something went wrong. Perhaps the object we tried to reference + was just removed. Try finding another definition. */ + return _dl_lookup_symbol_skip (undef_name, undef_map, ref, + symbol_scope, skip_map); + + break; + } if (current_value.s == NULL) { @@ -157,7 +318,7 @@ _dl_lookup_symbol_skip (const char *undef_name, return 0; } - if (_dl_debug_bindings) + if (__builtin_expect (_dl_debug_bindings, 0)) _dl_debug_message (1, "binding file ", (reference_name && reference_name[0] ? reference_name @@ -198,7 +359,25 @@ _dl_lookup_versioned_symbol (const char *undef_name, ¤t_value, *scope, 0, version, NULL, reloc_type); if (res > 0) - break; + { + /* We have to check whether this would bind UNDEF_MAP to an object + in the global scope which was dynamically loaded. In this case + we have to prevent the latter from being unloaded unless the + UNDEF_MAP object is also unloaded. */ + if (current_value.m->l_global + && (__builtin_expect (current_value.m->l_type, lt_library) + == lt_loaded) + && undef_map != current_value.m + /* Add UNDEF_MAP to the dependencies. */ + && add_dependency (undef_map, current_value.m) < 0) + /* Something went wrong. Perhaps the object we tried to reference + was just removed. Try finding another definition. */ + return _dl_lookup_versioned_symbol (undef_name, undef_map, ref, + symbol_scope, version, + reloc_type); + + break; + } if (res < 0) { @@ -232,7 +411,7 @@ _dl_lookup_versioned_symbol (const char *undef_name, return 0; } - if (_dl_debug_bindings) + if (__builtin_expect (_dl_debug_bindings, 0)) _dl_debug_message (1, "binding file ", (reference_name && reference_name[0] ? reference_name @@ -271,15 +450,49 @@ _dl_lookup_versioned_symbol_skip (const char *undef_name, for (i = 0; (*scope)->r_duplist[i] != skip_map; ++i) assert (i < (*scope)->r_nduplist); - if (i >= (*scope)->r_nlist - || ! do_lookup_versioned (undef_name, undef_map, hash, *ref, - ¤t_value, *scope, i, version, skip_map, - 0)) + if (i < (*scope)->r_nlist + && do_lookup_versioned (undef_name, undef_map, hash, *ref, + ¤t_value, *scope, i, version, skip_map, 0)) + { + /* We have to check whether this would bind UNDEF_MAP to an object + in the global scope which was dynamically loaded. In this case + we have to prevent the latter from being unloaded unless the + UNDEF_MAP object is also unloaded. */ + if (current_value.m->l_global + && (__builtin_expect (current_value.m->l_type, lt_library) + == lt_loaded) + && undef_map != current_value.m + /* Add UNDEF_MAP to the dependencies. */ + && add_dependency (undef_map, current_value.m) < 0) + /* Something went wrong. Perhaps the object we tried to reference + was just removed. Try finding another definition. */ + return _dl_lookup_versioned_symbol_skip (undef_name, undef_map, ref, + symbol_scope, version, + skip_map); + } + else while (*++scope) if (do_lookup_versioned (undef_name, undef_map, hash, *ref, ¤t_value, *scope, 0, version, skip_map, 0)) - break; + { + /* We have to check whether this would bind UNDEF_MAP to an object + in the global scope which was dynamically loaded. In this case + we have to prevent the latter from being unloaded unless the + UNDEF_MAP object is also unloaded. */ + if (current_value.m->l_global + && (__builtin_expect (current_value.m->l_type, lt_library) + == lt_loaded) + && undef_map != current_value.m + /* Add UNDEF_MAP to the dependencies. */ + && add_dependency (undef_map, current_value.m) < 0) + /* Something went wrong. Perhaps the object we tried to reference + was just removed. Try finding another definition. */ + return _dl_lookup_versioned_symbol_skip (undef_name, undef_map, + ref, symbol_scope, + version, skip_map); + break; + } if (current_value.s == NULL) { @@ -298,7 +511,7 @@ _dl_lookup_versioned_symbol_skip (const char *undef_name, return 0; } - if (_dl_debug_bindings) + if (__builtin_expect (_dl_debug_bindings, 0)) _dl_debug_message (1, "binding file ", (reference_name && reference_name[0] ? reference_name diff --git a/elf/dl-open.c b/elf/dl-open.c index f110a512cc..15ed24fff2 100644 --- a/elf/dl-open.c +++ b/elf/dl-open.c @@ -63,7 +63,7 @@ static void show_scope (struct link_map *new); This must be a recursive lock since the initializer function of the loaded object might as well require a call to this function. At this time it is not anymore a problem to modify the tables. */ -__libc_lock_define_initialized_recursive (, _dl_load_lock) +__libc_lock_define (extern, _dl_load_lock) extern size_t _dl_platformlen; diff --git a/elf/dl-support.c b/elf/dl-support.c index 8201ced490..68973cc5c1 100644 --- a/elf/dl-support.c +++ b/elf/dl-support.c @@ -25,6 +25,7 @@ #include <unistd.h> #include <ldsodefs.h> #include <dl-machine.h> +#include <bits/libc-lock.h> extern char *__progname; char **_dl_argv = &__progname; /* This is checked for some error messages. */ @@ -81,6 +82,15 @@ struct r_scope_elem *_dl_main_searchlist = &_dl_initial_searchlist; /* Nonzero during startup. */ int _dl_starting_up = 1; +/* During the program run we must not modify the global data of + loaded shared object simultanously in two threads. Therefore we + protect `_dl_open' and `_dl_close' in dl-close.c. + + This must be a recursive lock since the initializer function of + the loaded object might as well require a call to this function. + At this time it is not anymore a problem to modify the tables. */ +__libc_lock_define_initialized_recursive (, _dl_load_lock) + static void non_dynamic_init (void) __attribute__ ((unused)); diff --git a/elf/link.h b/elf/link.h index e4c2fea1f9..0588b523e3 100644 --- a/elf/link.h +++ b/elf/link.h @@ -208,6 +208,11 @@ struct link_map /* List of object in order of the init and fini calls. */ struct link_map **l_initfini; + + /* List of the dependencies introduced through symbol binding. */ + unsigned int l_reldepsmax; + unsigned int l_reldepsact; + struct link_map **l_reldeps; }; #endif /* link.h */ diff --git a/elf/rtld.c b/elf/rtld.c index 562e44aec8..24968f87cd 100644 --- a/elf/rtld.c +++ b/elf/rtld.c @@ -27,6 +27,7 @@ #include <entry.h> #include <fpu_control.h> #include <hp-timing.h> +#include <bits/libc-lock.h> #include "dynamic-link.h" #include "dl-librecon.h" @@ -105,6 +106,15 @@ struct r_scope_elem _dl_initial_searchlist; /* Array which is used when looking up in the global scope. */ struct r_scope_elem *_dl_global_scope[2]; +/* During the program run we must not modify the global data of + loaded shared object simultanously in two threads. Therefore we + protect `_dl_open' and `_dl_close' in dl-close.c. + + This must be a recursive lock since the initializer function of + the loaded object might as well require a call to this function. + At this time it is not anymore a problem to modify the tables. */ +__libc_lock_define_initialized_recursive (, _dl_load_lock) + /* Set nonzero during loading and initialization of executable and libraries, cleared before the executable's entry point runs. This must not be initialized to nonzero, because the unused dynamic |