void
_dl_cleanup_objects()
{
elf_object_t *nobj, *head;
struct dep_node *n, *next;
n = TAILQ_FIRST(&_dlopened_child_list);
while (n != NULL) {
next = TAILQ_NEXT(n, next_sib);
if (OBJECT_DLREF_CNT(n->data) == 0) {
TAILQ_REMOVE(&_dlopened_child_list, n, next_sib);
_dl_free(n);
}
n = next;
}
head = free_objects;
free_objects = NULL;
while (head != NULL) {
if (head->load_name)
_dl_free(head->load_name);
_dl_tailq_free(TAILQ_FIRST(&head->grpsym_list));
_dl_tailq_free(TAILQ_FIRST(&head->child_list));
_dl_tailq_free(TAILQ_FIRST(&head->grpref_list));
nobj = head->next;
_dl_free(head);
head = nobj;
}
}
void
internal_function
_dl_deallocate_tls (void *tcb, bool dealloc_tcb)
{
dtv_t *dtv = GET_DTV (tcb);
size_t cnt;
/* We need to free the memory allocated for non-static TLS. */
for (cnt = 0; cnt < dtv[-1].counter; ++cnt)
if (! dtv[1 + cnt].pointer.is_static
&& dtv[1 + cnt].pointer.val != TLS_DTV_UNALLOCATED)
_dl_free (dtv[1 + cnt].pointer.val);
/* The array starts with dtv[-1]. */
if (dtv != _dl_initial_dtv)
_dl_free (dtv - 1);
if (dealloc_tcb)
{
# ifdef TLS_TCB_AT_TP
/* The TCB follows the TLS blocks. Back up to free the whole block. */
tcb -= _dl_tls_static_size - TLS_TCB_SIZE;
# elif defined(TLS_DTV_AT_TP)
/* Back up the TLS_PRE_TCB_SIZE bytes. */
tcb -= (TLS_PRE_TCB_SIZE + _dl_tls_static_align - 1)
& ~(_dl_tls_static_align - 1);
# endif
_dl_free (tcb);
}
}
/*
* close a directory.
*/
int
_dl_closedir(DIR *dirp)
{
int fd;
int ret;
fd = dirp->dd_fd;
dirp->dd_fd = -1;
dirp->dd_loc = 0;
_dl_free((void *)dirp->dd_buf);
_dl_free((void *)dirp);
ret = _dl_close(fd);
return (ret);
}
/*
* Open a directory.
*/
DIR *
_dl_opendir(const char *name)
{
DIR *dirp;
int fd;
struct stat sb;
if ((fd = _dl_open(name, O_RDONLY | O_NONBLOCK)) < 0)
return (NULL);
if (_dl_fstat(fd, &sb) || !S_ISDIR(sb.st_mode)) {
_dl_close(fd);
return (NULL);
}
if (_dl_fcntl(fd, F_SETFD, FD_CLOEXEC) < 0 ||
(dirp = (DIR *)_dl_malloc(sizeof(DIR))) == NULL) {
_dl_close(fd);
return (NULL);
}
dirp->dd_len = _dl_round_page(sb.st_blksize);
dirp->dd_buf = _dl_malloc(dirp->dd_len);
if (dirp->dd_buf == NULL) {
_dl_free(dirp);
_dl_close (fd);
return (NULL);
}
dirp->dd_seek = 0;
dirp->dd_loc = 0;
dirp->dd_fd = fd;
return (dirp);
}
void
_dl_tailq_free(struct dep_node *n)
{
struct dep_node *next;
while (n != NULL) {
next = TAILQ_NEXT(n, next_sib);
_dl_free(n);
n = next;
}
}
void
_dl_load_list_free(struct load_list *load_list)
{
struct load_list *next;
while (load_list != NULL) {
next = load_list->next;
_dl_free(load_list);
load_list = next;
}
}
void
_dl_load_list_free(struct load_list *load_list)
{
struct load_list *next;
Elf_Addr align = _dl_pagesz - 1;
while (load_list != NULL) {
if (load_list->start != NULL)
_dl_munmap(load_list->start,
((load_list->size) + align) & ~align);
next = load_list->next;
_dl_free(load_list);
load_list = next;
}
}
internal_function
_dl_allocate_tls_storage (void)
{
void *result;
size_t size = _dl_tls_static_size;
# if defined(TLS_DTV_AT_TP)
/* Memory layout is:
[ TLS_PRE_TCB_SIZE ] [ TLS_TCB_SIZE ] [ TLS blocks ]
^ This should be returned. */
size += (TLS_PRE_TCB_SIZE + _dl_tls_static_align - 1)
& ~(_dl_tls_static_align - 1);
# endif
/* Allocate a correctly aligned chunk of memory. */
result = _dl_memalign (_dl_tls_static_align, size);
if (__builtin_expect (result != NULL, 1))
{
/* Allocate the DTV. */
void *allocated = result;
# ifdef TLS_TCB_AT_TP
/* The TCB follows the TLS blocks. */
result = (char *) result + size - TLS_TCB_SIZE;
/* Clear the TCB data structure. We can't ask the caller (i.e.
libpthread) to do it, because we will initialize the DTV et al. */
_dl_memset (result, '\0', TLS_TCB_SIZE);
# elif defined(TLS_DTV_AT_TP)
result = (char *) result + size - _dl_tls_static_size;
/* Clear the TCB data structure and TLS_PRE_TCB_SIZE bytes before it.
We can't ask the caller (i.e. libpthread) to do it, because we will
initialize the DTV et al. */
_dl_memset ((char *) result - TLS_PRE_TCB_SIZE, '\0',
TLS_PRE_TCB_SIZE + TLS_TCB_SIZE);
# endif
result = allocate_dtv (result);
if (result == NULL)
_dl_free (allocated);
}
return result;
}
struct link_map *
_dl_update_slotinfo (unsigned long int req_modid)
{
struct link_map *the_map = NULL;
dtv_t *dtv = THREAD_DTV ();
/* The global dl_tls_dtv_slotinfo array contains for each module
index the generation counter current when the entry was created.
This array never shrinks so that all module indices which were
valid at some time can be used to access it. Before the first
use of a new module index in this function the array was extended
appropriately. Access also does not have to be guarded against
modifications of the array. It is assumed that pointer-size
values can be read atomically even in SMP environments. It is
possible that other threads at the same time dynamically load
code and therefore add to the slotinfo list. This is a problem
since we must not pick up any information about incomplete work.
The solution to this is to ignore all dtv slots which were
created after the one we are currently interested. We know that
dynamic loading for this module is completed and this is the last
load operation we know finished. */
unsigned long int idx = req_modid;
struct dtv_slotinfo_list *listp = _dl_tls_dtv_slotinfo_list;
_dl_debug_early ("Updating slotinfo for module %d\n", req_modid);
while (idx >= listp->len)
{
idx -= listp->len;
listp = listp->next;
}
if (dtv[0].counter < listp->slotinfo[idx].gen)
{
/* The generation counter for the slot is higher than what the
current dtv implements. We have to update the whole dtv but
only those entries with a generation counter <= the one for
the entry we need. */
size_t new_gen = listp->slotinfo[idx].gen;
size_t total = 0;
/* We have to look through the entire dtv slotinfo list. */
listp = _dl_tls_dtv_slotinfo_list;
do
{
size_t cnt;
for (cnt = total == 0 ? 1 : 0; cnt < listp->len; ++cnt)
{
size_t gen = listp->slotinfo[cnt].gen;
if (gen > new_gen)
/* This is a slot for a generation younger than the
one we are handling now. It might be incompletely
set up so ignore it. */
continue;
/* If the entry is older than the current dtv layout we
know we don't have to handle it. */
if (gen <= dtv[0].counter)
continue;
/* If there is no map this means the entry is empty. */
struct link_map *map = listp->slotinfo[cnt].map;
if (map == NULL)
{
/* If this modid was used at some point the memory
might still be allocated. */
if (! dtv[total + cnt].pointer.is_static
&& dtv[total + cnt].pointer.val != TLS_DTV_UNALLOCATED)
{
_dl_free (dtv[total + cnt].pointer.val);
dtv[total + cnt].pointer.val = TLS_DTV_UNALLOCATED;
}
continue;
}
/* Check whether the current dtv array is large enough. */
size_t modid = map->l_tls_modid;
_dl_assert (total + cnt == modid);
if (dtv[-1].counter < modid)
{
/* Reallocate the dtv. */
dtv_t *newp;
size_t newsize = _dl_tls_max_dtv_idx + DTV_SURPLUS;
size_t oldsize = dtv[-1].counter;
_dl_assert (map->l_tls_modid <= newsize);
if (dtv == _dl_initial_dtv)
{
/* This is the initial dtv that was allocated
during rtld startup using the dl-minimal.c
malloc instead of the real malloc. We can't
free it, we have to abandon the old storage. */
newp = _dl_malloc ((2 + newsize) * sizeof (dtv_t));
if (newp == NULL)
oom ();
_dl_memcpy (newp, &dtv[-1], oldsize * sizeof (dtv_t));
}
else
{
newp = _dl_realloc (&dtv[-1],
(2 + newsize) * sizeof (dtv_t));
if (newp == NULL)
oom ();
}
newp[0].counter = newsize;
/* Clear the newly allocated part. */
_dl_memset (newp + 2 + oldsize, '\0',
(newsize - oldsize) * sizeof (dtv_t));
/* Point dtv to the generation counter. */
dtv = &newp[1];
/* Install this new dtv in the thread data
structures. */
INSTALL_NEW_DTV (dtv);
}
/* If there is currently memory allocate for this
dtv entry free it. */
/* XXX Ideally we will at some point create a memory
pool. */
if (! dtv[modid].pointer.is_static
&& dtv[modid].pointer.val != TLS_DTV_UNALLOCATED)
/* Note that free is called for NULL is well. We
deallocate even if it is this dtv entry we are
supposed to load. The reason is that we call
memalign and not malloc. */
_dl_free (dtv[modid].pointer.val);
/* This module is loaded dynamically- We defer memory
allocation. */
dtv[modid].pointer.is_static = false;
dtv[modid].pointer.val = TLS_DTV_UNALLOCATED;
if (modid == req_modid)
the_map = map;
}
total += listp->len;
}
while ((listp = listp->next) != NULL);
/* This will be the new maximum generation counter. */
dtv[0].counter = new_gen;
}
return the_map;
}
/*
* char *dl_realpath(const char *path, char resolved[PATH_MAX]);
*
* Find the real name of path, by removing all ".", ".." and symlink
* components. Returns (resolved) on success, or (NULL) on failure,
* in which case the path which caused trouble is left in (resolved).
*/
char *
_dl_realpath(const char *path, char *resolved)
{
struct stat sb;
const char *p, *s;
char *q;
size_t left_len, resolved_len;
unsigned symlinks;
int slen, mem_allocated, ret;
char left[PATH_MAX], next_token[PATH_MAX], symlink[PATH_MAX];
if (path[0] == '\0') {
return (NULL);
}
if (resolved == NULL) {
resolved = _dl_malloc(PATH_MAX);
if (resolved == NULL)
return (NULL);
mem_allocated = 1;
} else
mem_allocated = 0;
symlinks = 0;
if (path[0] == '/') {
resolved[0] = '/';
resolved[1] = '\0';
if (path[1] == '\0')
return (resolved);
resolved_len = 1;
left_len = _dl_strlcpy(left, path + 1, sizeof(left));
} else {
if (_dl_getcwd(resolved, PATH_MAX) <= 0) {
if (mem_allocated)
_dl_free(resolved);
else
_dl_strlcpy(resolved, ".", PATH_MAX);
return (NULL);
}
resolved_len = _dl_strlen(resolved);
left_len = _dl_strlcpy(left, path, sizeof(left));
}
if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
goto err;
}
/*
* Iterate over path components in `left'.
*/
while (left_len != 0) {
/*
* Extract the next path component and adjust `left'
* and its length.
*/
p = _dl_strchr(left, '/');
s = p ? p : left + left_len;
if (s - left >= sizeof(next_token)) {
goto err;
}
_dl_bcopy(left, next_token, s - left);
next_token[s - left] = '\0';
left_len -= s - left;
if (p != NULL)
_dl_bcopy(s + 1, left, left_len + 1);
if (resolved[resolved_len - 1] != '/') {
if (resolved_len + 1 >= PATH_MAX) {
goto err;
}
resolved[resolved_len++] = '/';
resolved[resolved_len] = '\0';
}
if (next_token[0] == '\0')
continue;
else if (_dl_strcmp(next_token, ".") == 0)
continue;
else if (_dl_strcmp(next_token, "..") == 0) {
/*
* Strip the last path component except when we have
* single "/"
*/
if (resolved_len > 1) {
resolved[resolved_len - 1] = '\0';
q = _dl_strrchr(resolved, '/') + 1;
*q = '\0';
resolved_len = q - resolved;
}
continue;
}
/*
* Append the next path component and lstat() it. If
* lstat() fails we still can return successfully if
* there are no more path components left.
*/
resolved_len = _dl_strlcat(resolved, next_token, PATH_MAX);
if (resolved_len >= PATH_MAX) {
goto err;
}
if ((ret = _dl_lstat(resolved, &sb)) != 0) {
if (ret == ENOENT && p == NULL) {
return (resolved);
}
goto err;
}
if (S_ISLNK(sb.st_mode)) {
if (symlinks++ > SYMLOOP_MAX) {
goto err;
}
slen = _dl_readlink(resolved, symlink, sizeof(symlink) - 1);
if (slen < 0)
goto err;
symlink[slen] = '\0';
if (symlink[0] == '/') {
resolved[1] = 0;
resolved_len = 1;
} else if (resolved_len > 1) {
/* Strip the last path component. */
resolved[resolved_len - 1] = '\0';
q = _dl_strrchr(resolved, '/') + 1;
*q = '\0';
resolved_len = q - resolved;
}
/*
* If there are any path components left, then
* append them to symlink. The result is placed
* in `left'.
*/
if (p != NULL) {
if (symlink[slen - 1] != '/') {
if (slen + 1 >= sizeof(symlink)) {
goto err;
}
symlink[slen] = '/';
symlink[slen + 1] = 0;
}
left_len = _dl_strlcat(symlink, left, sizeof(symlink));
if (left_len >= sizeof(left)) {
goto err;
}
}
left_len = _dl_strlcpy(left, symlink, sizeof(left));
}
}
/*
* Remove trailing slash except when the resolved pathname
* is a single "/".
*/
if (resolved_len > 1 && resolved[resolved_len - 1] == '/')
resolved[resolved_len - 1] = '\0';
return (resolved);
err:
if (mem_allocated)
_dl_free(resolved);
return (NULL);
}
/*
* Initialize a new dynamic object.
*/
elf_object_t *
_dl_finalize_object(const char *objname, Elf_Dyn *dynp, Elf_Phdr *phdrp,
int phdrc, const int objtype, const long lbase, const long obase)
{
elf_object_t *object;
#if 0
_dl_printf("objname [%s], dynp %p, objtype %x lbase %lx, obase %lx\n",
objname, dynp, objtype, lbase, obase);
#endif
object = _dl_calloc(1, sizeof(elf_object_t));
if (object == NULL)
_dl_exit(7);
object->prev = object->next = NULL;
object->load_dyn = dynp;
while (dynp->d_tag != DT_NULL) {
if (dynp->d_tag < DT_NUM)
object->Dyn.info[dynp->d_tag] = dynp->d_un.d_val;
else if (dynp->d_tag >= DT_LOPROC &&
dynp->d_tag < DT_LOPROC + DT_PROCNUM)
object->Dyn.info[dynp->d_tag + DT_NUM - DT_LOPROC] =
dynp->d_un.d_val;
if (dynp->d_tag == DT_TEXTREL)
object->dyn.textrel = 1;
if (dynp->d_tag == DT_SYMBOLIC)
object->dyn.symbolic = 1;
if (dynp->d_tag == DT_BIND_NOW)
object->obj_flags |= DF_1_NOW;
if (dynp->d_tag == DT_FLAGS_1)
object->obj_flags |= dynp->d_un.d_val;
if (dynp->d_tag == DT_RELACOUNT)
object->relacount = dynp->d_un.d_val;
if (dynp->d_tag == DT_RELCOUNT)
object->relcount = dynp->d_un.d_val;
dynp++;
}
DL_DEB((" flags %s = 0x%x\n", objname, object->obj_flags ));
object->obj_type = objtype;
if (_dl_loading_object == NULL) {
/*
* no loading object, object is the loading object,
* as it is either executable, or dlopened()
*/
_dl_loading_object = object;
}
if ((object->obj_flags & DF_1_NOOPEN) != 0 &&
_dl_loading_object->obj_type == OBJTYPE_DLO &&
_dl_traceld == NULL) {
_dl_free(object);
_dl_errno = DL_CANT_LOAD_OBJ;
return(NULL);
}
/*
* Now relocate all pointer to dynamic info, but only
* the ones which have pointer values.
*/
if (object->Dyn.info[DT_PLTGOT])
object->Dyn.info[DT_PLTGOT] += obase;
if (object->Dyn.info[DT_HASH])
object->Dyn.info[DT_HASH] += obase;
if (object->Dyn.info[DT_STRTAB])
object->Dyn.info[DT_STRTAB] += obase;
if (object->Dyn.info[DT_SYMTAB])
object->Dyn.info[DT_SYMTAB] += obase;
if (object->Dyn.info[DT_RELA])
object->Dyn.info[DT_RELA] += obase;
if (object->Dyn.info[DT_SONAME])
object->Dyn.info[DT_SONAME] += object->Dyn.info[DT_STRTAB];
if (object->Dyn.info[DT_RPATH])
object->Dyn.info[DT_RPATH] += object->Dyn.info[DT_STRTAB];
if (object->Dyn.info[DT_REL])
object->Dyn.info[DT_REL] += obase;
if (object->Dyn.info[DT_INIT])
object->Dyn.info[DT_INIT] += obase;
if (object->Dyn.info[DT_FINI])
object->Dyn.info[DT_FINI] += obase;
if (object->Dyn.info[DT_JMPREL])
object->Dyn.info[DT_JMPREL] += obase;
if (object->Dyn.info[DT_HASH] != 0) {
Elf_Word *hashtab = (Elf_Word *)object->Dyn.info[DT_HASH];
object->nbuckets = hashtab[0];
object->nchains = hashtab[1];
object->buckets = hashtab + 2;
object->chains = object->buckets + object->nbuckets;
}
object->phdrp = phdrp;
object->phdrc = phdrc;
object->load_base = lbase;
object->obj_base = obase;
object->load_name = _dl_strdup(objname);
if (object->load_name == NULL)
_dl_exit(7);
object->load_object = _dl_loading_object;
if (object->load_object == object)
DL_DEB(("head %s\n", object->load_name));
DL_DEB(("obj %s has %s as head\n", object->load_name,
_dl_loading_object->load_name ));
object->refcount = 0;
TAILQ_INIT(&object->child_list);
object->opencount = 0; /* # dlopen() & exe */
object->grprefcount = 0;
/* default dev, inode for dlopen-able objects. */
object->dev = 0;
object->inode = 0;
object->grpsym_gen = 0;
TAILQ_INIT(&object->grpsym_list);
TAILQ_INIT(&object->grpref_list);
if (object->dyn.rpath) {
object->rpath = _dl_split_path(object->dyn.rpath);
if ((object->obj_flags & DF_1_ORIGIN) && _dl_trust)
_dl_origin_subst(object);
}
_dl_trace_object_setup(object);
return (object);
}
/*
* Perform $ORIGIN substitutions on path
*/
static void
_dl_origin_subst_path(elf_object_t *object, const char *origin_path,
char **path)
{
char tmp_path[PATH_MAX];
char *new_path, *tp;
const char *pp, *name, *value;
static struct utsname uts;
size_t value_len;
int skip_brace;
if (uts.sysname[0] == '\0') {
if (_dl_uname(&uts) != 0)
return;
}
tp = tmp_path;
pp = *path;
while (*pp != '\0' && (tp - tmp_path) < sizeof(tmp_path)) {
/* copy over chars up to but not including $ */
while (*pp != '\0' && *pp != '$' &&
(tp - tmp_path) < sizeof(tmp_path))
*tp++ = *pp++;
/* substitution sequence detected */
if (*pp == '$' && (tp - tmp_path) < sizeof(tmp_path)) {
pp++;
if ((skip_brace = (*pp == '{')))
pp++;
/* skip over name */
name = pp;
while (_dl_isalnum((unsigned char)*pp) || *pp == '_')
pp++;
switch (_dl_subst_name(name, pp - name)) {
case SUBST_ORIGIN:
value = origin_path;
break;
case SUBST_OSNAME:
value = uts.sysname;
break;
case SUBST_OSREL:
value = uts.release;
break;
case SUBST_PLATFORM:
value = uts.machine;
break;
default:
value = "";
}
value_len = _dl_strlen(value);
if (value_len >= sizeof(tmp_path) - (tp - tmp_path))
return;
_dl_bcopy(value, tp, value_len);
tp += value_len;
if (skip_brace && *pp == '}')
pp++;
}
}
/* no substitution made if result exceeds sizeof(tmp_path) */
if (tp - tmp_path >= sizeof(tmp_path))
return;
/* NULL terminate tmp_path */
*tp = '\0';
if (_dl_strcmp(tmp_path, *path) == 0)
return;
new_path = _dl_strdup(tmp_path);
if (new_path == NULL)
return;
DL_DEB(("orig_path %s\n", *path));
DL_DEB(("new_path %s\n", new_path));
_dl_free(*path);
*path = new_path;
}