/*
* 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);
}
/*
* Extract a trace specification field, and setup the tracespec struct
* accordingly.
*/
const char *
_dl_trace_parse_spec(const char *var, struct tracespec *spec)
{
const char *start, *end;
if (*var == '!') {
spec->inverse = 1;
var++;
}
start = var;
end = _dl_strchr(start, ':');
if (end == NULL)
end = start + _dl_strlen(start);
if (end != start) {
spec->spec = _dl_malloc(1 + end - start);
if (spec->spec == NULL)
_dl_exit(8);
_dl_bcopy(start, spec->spec, end - start);
spec->spec[end - start] = '\0';
}
if (*end == ':')
end++;
return end;
}
/*
* We call this function when we have just read an ELF library or executable.
* We add the relevant info to the symbol chain, so that we can resolve all
* externals properly.
*/
struct elf_resolve *_dl_add_elf_hash_table(const char *libname,
DL_LOADADDR_TYPE loadaddr, unsigned long *dynamic_info, unsigned long dynamic_addr,
attribute_unused unsigned long dynamic_size)
{
Elf_Symndx *hash_addr;
struct elf_resolve *tpnt;
int i;
if (!_dl_loaded_modules) {
tpnt = _dl_loaded_modules = (struct elf_resolve *) _dl_malloc(sizeof(struct elf_resolve));
_dl_memset(tpnt, 0, sizeof(struct elf_resolve));
} else {
tpnt = _dl_loaded_modules;
while (tpnt->next)
tpnt = tpnt->next;
tpnt->next = (struct elf_resolve *) _dl_malloc(sizeof(struct elf_resolve));
_dl_memset(tpnt->next, 0, sizeof(struct elf_resolve));
tpnt->next->prev = tpnt;
tpnt = tpnt->next;
}
tpnt->next = NULL;
tpnt->init_flag = 0;
tpnt->libname = _dl_strdup(libname);
tpnt->dynamic_addr = (ElfW(Dyn) *)dynamic_addr;
tpnt->libtype = loaded_file;
#ifdef __LDSO_GNU_HASH_SUPPORT__
if (dynamic_info[DT_GNU_HASH_IDX] != 0) {
Elf32_Word *hash32 = (Elf_Symndx*)dynamic_info[DT_GNU_HASH_IDX];
tpnt->nbucket = *hash32++;
Elf32_Word symbias = *hash32++;
Elf32_Word bitmask_nwords = *hash32++;
/* Must be a power of two. */
_dl_assert ((bitmask_nwords & (bitmask_nwords - 1)) == 0);
tpnt->l_gnu_bitmask_idxbits = bitmask_nwords - 1;
tpnt->l_gnu_shift = *hash32++;
tpnt->l_gnu_bitmask = (ElfW(Addr) *) hash32;
hash32 += __ELF_NATIVE_CLASS / 32 * bitmask_nwords;
tpnt->l_gnu_buckets = hash32;
hash32 += tpnt->nbucket;
tpnt->l_gnu_chain_zero = hash32 - symbias;
} else
void *
_dl_calloc (size_t __nmemb, size_t __size)
{
void *result;
size_t size = (__size * __nmemb);
if (_dl_calloc_function)
return (*_dl_calloc_function) (__nmemb, __size);
if ((result = _dl_malloc(size)) != NULL) {
_dl_memset(result, 0, size);
}
return result;
}
Elf_Addr
_dl_md_plabel(Elf_Addr pc, Elf_Addr *sl)
{
hppa_plabel_t key, *p;
key.pc = pc;
key.sl = sl;
p = SPLAY_FIND(_dl_md_plabels, &_dl_md_plabel_root, &key);
if (p == NULL) {
p = _dl_malloc(sizeof(*p));
if (p == NULL)
_dl_exit(5);
p->pc = pc;
p->sl = sl;
SPLAY_INSERT(_dl_md_plabels, &_dl_md_plabel_root, p);
}
return (Elf_Addr)p | 2;
}
void
_dl_add_to_slotinfo (struct link_map *l)
{
/* Now that we know the object is loaded successfully add
modules containing TLS data to the dtv info table. We
might have to increase its size. */
struct dtv_slotinfo_list *listp;
struct dtv_slotinfo_list *prevp;
size_t idx = l->l_tls_modid;
_dl_debug_early("Adding to slotinfo for %s\n", l->l_name);
/* Find the place in the dtv slotinfo list. */
listp = _dl_tls_dtv_slotinfo_list;
prevp = NULL; /* Needed to shut up gcc. */
do
{
/* Does it fit in the array of this list element? */
if (idx < listp->len)
break;
idx -= listp->len;
prevp = listp;
listp = listp->next;
}
while (listp != NULL);
if (listp == NULL)
{
/* When we come here it means we have to add a new element
to the slotinfo list. And the new module must be in
the first slot. */
_dl_assert (idx == 0);
listp = prevp->next = (struct dtv_slotinfo_list *)
_dl_malloc (sizeof (struct dtv_slotinfo_list)
+ TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo));
if (listp == NULL)
{
/* We ran out of memory. We will simply fail this
call but don't undo anything we did so far. The
application will crash or be terminated anyway very
soon. */
/* We have to do this since some entries in the dtv
slotinfo array might already point to this
generation. */
++_dl_tls_generation;
_dl_dprintf (_dl_debug_file,
"cannot create TLS data structures: ABORT\n");
_dl_exit (127);
}
listp->len = TLS_SLOTINFO_SURPLUS;
listp->next = NULL;
_dl_memset (listp->slotinfo, '\0',
TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo));
}
/* Add the information into the slotinfo data structure. */
listp->slotinfo[idx].map = l;
listp->slotinfo[idx].gen = _dl_tls_generation + 1;
/* ??? ideally this would be done once per call to dlopen. However there's
no easy way to indicate whether a library used TLS, so do it here
instead. */
/* Bump the TLS generation number. */
_dl_tls_generation++;
}
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;
}
/*
* 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_malloc(sizeof(elf_object_t));
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 = RTLD_NOW;
dynp++;
}
/*
* 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] += obase;
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->obj_type = objtype;
object->load_base = lbase;
object->obj_base = obase;
object->load_name = _dl_strdup(objname);
if (_dl_loading_object == NULL) {
/*
* no loading object, object is the loading object,
* as it is either executable, or dlopened()
*/
_dl_loading_object = object->load_object = object;
DL_DEB(("head %s\n", object->load_name ));
} else {
object->load_object = _dl_loading_object;
}
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;
TAILQ_INIT(&object->grpsym_list);
TAILQ_INIT(&object->grpref_list);
return(object);
}
elf_object_t *
_dl_tryload_shlib(const char *libname, int type, int flags)
{
int libfile, i;
struct load_list *next_load, *load_list = NULL;
Elf_Addr maxva = 0, minva = ELFDEFNNAME(NO_ADDR);
Elf_Addr libaddr, loff, align = _dl_pagesz - 1;
elf_object_t *object;
char hbuf[4096];
Elf_Dyn *dynp = 0;
Elf_Ehdr *ehdr;
Elf_Phdr *phdp;
struct stat sb;
void *prebind_data;
#define ROUND_PG(x) (((x) + align) & ~(align))
#define TRUNC_PG(x) ((x) & ~(align))
libfile = _dl_open(libname, O_RDONLY);
if (libfile < 0) {
_dl_errno = DL_CANT_OPEN;
return(0);
}
if ( _dl_fstat(libfile, &sb) < 0) {
_dl_errno = DL_CANT_OPEN;
return(0);
}
for (object = _dl_objects; object != NULL; object = object->next) {
if (object->dev == sb.st_dev &&
object->inode == sb.st_ino) {
object->obj_flags |= flags & DF_1_GLOBAL;
_dl_close(libfile);
if (_dl_loading_object == NULL)
_dl_loading_object = object;
if (object->load_object != _dl_objects &&
object->load_object != _dl_loading_object) {
_dl_link_grpref(object->load_object,
_dl_loading_object);
}
return(object);
}
}
_dl_read(libfile, hbuf, sizeof(hbuf));
ehdr = (Elf_Ehdr *)hbuf;
if (ehdr->e_ident[0] != ELFMAG0 || ehdr->e_ident[1] != ELFMAG1 ||
ehdr->e_ident[2] != ELFMAG2 || ehdr->e_ident[3] != ELFMAG3 ||
ehdr->e_type != ET_DYN || ehdr->e_machine != MACHID) {
_dl_close(libfile);
_dl_errno = DL_NOT_ELF;
return(0);
}
/*
* Alright, we might have a winner!
* Figure out how much VM space we need.
*/
phdp = (Elf_Phdr *)(hbuf + ehdr->e_phoff);
for (i = 0; i < ehdr->e_phnum; i++, phdp++) {
switch (phdp->p_type) {
case PT_LOAD:
if (phdp->p_vaddr < minva)
minva = phdp->p_vaddr;
if (phdp->p_vaddr + phdp->p_memsz > maxva)
maxva = phdp->p_vaddr + phdp->p_memsz;
break;
case PT_DYNAMIC:
dynp = (Elf_Dyn *)phdp->p_vaddr;
break;
case PT_TLS:
_dl_printf("%s: unsupported TLS program header in %s\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_LOAD_OBJ;
return(0);
default:
break;
}
}
minva = TRUNC_PG(minva);
maxva = ROUND_PG(maxva);
/*
* We map the entire area to see that we can get the VM
* space required. Map it unaccessible to start with.
*
* We must map the file we'll map later otherwise the VM
* system won't be able to align the mapping properly
* on VAC architectures.
*/
libaddr = (Elf_Addr)_dl_mmap(0, maxva - minva, PROT_NONE,
MAP_PRIVATE|MAP_FILE, libfile, 0);
if (_dl_mmap_error(libaddr)) {
_dl_printf("%s: rtld mmap failed mapping %s.\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_MMAP;
return(0);
}
loff = libaddr - minva;
phdp = (Elf_Phdr *)(hbuf + ehdr->e_phoff);
for (i = 0; i < ehdr->e_phnum; i++, phdp++) {
switch (phdp->p_type) {
case PT_LOAD: {
char *start = (char *)(TRUNC_PG(phdp->p_vaddr)) + loff;
Elf_Addr off = (phdp->p_vaddr & align);
Elf_Addr size = off + phdp->p_filesz;
void *res;
if (size != 0) {
res = _dl_mmap(start, ROUND_PG(size),
PFLAGS(phdp->p_flags),
MAP_FIXED|MAP_PRIVATE, libfile,
TRUNC_PG(phdp->p_offset));
} else
res = NULL; /* silence gcc */
next_load = _dl_malloc(sizeof(struct load_list));
next_load->next = load_list;
load_list = next_load;
next_load->start = start;
next_load->size = size;
next_load->prot = PFLAGS(phdp->p_flags);
if (size != 0 && _dl_mmap_error(res)) {
_dl_printf("%s: rtld mmap failed mapping %s.\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_MMAP;
_dl_munmap((void *)libaddr, maxva - minva);
_dl_load_list_free(load_list);
return(0);
}
if (phdp->p_flags & PF_W) {
/* Zero out everything past the EOF */
if ((size & align) != 0)
_dl_memset(start + size, 0,
_dl_pagesz - (size & align));
if (ROUND_PG(size) ==
ROUND_PG(off + phdp->p_memsz))
continue;
start = start + ROUND_PG(size);
size = ROUND_PG(off + phdp->p_memsz) -
ROUND_PG(size);
res = _dl_mmap(start, size,
PFLAGS(phdp->p_flags),
MAP_FIXED|MAP_PRIVATE|MAP_ANON, -1, 0);
if (_dl_mmap_error(res)) {
_dl_printf("%s: rtld mmap failed mapping %s.\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_MMAP;
_dl_munmap((void *)libaddr, maxva - minva);
_dl_load_list_free(load_list);
return(0);
}
}
break;
}
case PT_OPENBSD_RANDOMIZE:
_dl_randombuf((char *)(phdp->p_vaddr + loff),
phdp->p_memsz);
break;
default:
break;
}
}
prebind_data = prebind_load_fd(libfile, libname);
_dl_close(libfile);
dynp = (Elf_Dyn *)((unsigned long)dynp + loff);
object = _dl_finalize_object(libname, dynp,
(Elf_Phdr *)((char *)libaddr + ehdr->e_phoff), ehdr->e_phnum,type,
libaddr, loff);
if (object) {
object->prebind_data = prebind_data;
object->load_size = maxva - minva; /*XXX*/
object->load_list = load_list;
/* set inode, dev from stat info */
object->dev = sb.st_dev;
object->inode = sb.st_ino;
object->obj_flags |= flags;
_dl_set_sod(object->load_name, &object->sod);
} else {
_dl_munmap((void *)libaddr, maxva - minva);
_dl_load_list_free(load_list);
}
return(object);
}
elf_object_t *
_dl_tryload_shlib(const char *libname, int type, int flags)
{
int libfile, i;
struct load_list *ld, *lowld = NULL;
elf_object_t *object;
Elf_Dyn *dynp = 0;
Elf_Ehdr *ehdr;
Elf_Phdr *phdp;
Elf_Addr load_end = 0;
Elf_Addr align = _dl_pagesz - 1, off, size;
struct stat sb;
void *prebind_data;
char hbuf[4096];
#define ROUND_PG(x) (((x) + align) & ~(align))
#define TRUNC_PG(x) ((x) & ~(align))
libfile = _dl_open(libname, O_RDONLY);
if (libfile < 0) {
_dl_errno = DL_CANT_OPEN;
return(0);
}
if ( _dl_fstat(libfile, &sb) < 0) {
_dl_errno = DL_CANT_OPEN;
return(0);
}
for (object = _dl_objects; object != NULL; object = object->next) {
if (object->dev == sb.st_dev &&
object->inode == sb.st_ino) {
object->obj_flags |= flags & RTLD_GLOBAL;
_dl_close(libfile);
if (_dl_loading_object == NULL)
_dl_loading_object = object;
if (object->load_object != _dl_objects &&
object->load_object != _dl_loading_object) {
_dl_link_grpref(object->load_object,
_dl_loading_object);
}
return(object);
}
}
_dl_read(libfile, hbuf, sizeof(hbuf));
ehdr = (Elf_Ehdr *)hbuf;
if (ehdr->e_ident[0] != ELFMAG0 || ehdr->e_ident[1] != ELFMAG1 ||
ehdr->e_ident[2] != ELFMAG2 || ehdr->e_ident[3] != ELFMAG3 ||
ehdr->e_type != ET_DYN || ehdr->e_machine != MACHID) {
_dl_close(libfile);
_dl_errno = DL_NOT_ELF;
return(0);
}
/* Insertion sort */
#define LDLIST_INSERT(ld) do { \
struct load_list **_ld; \
for (_ld = &lowld; *_ld != NULL; _ld = &(*_ld)->next) \
if ((*_ld)->moff > ld->moff) \
break; \
ld->next = *_ld; \
*_ld = ld; \
} while (0)
/*
* Alright, we might have a winner!
* Figure out how much VM space we need and set up the load
* list that we'll use to find free VM space.
*/
phdp = (Elf_Phdr *)(hbuf + ehdr->e_phoff);
for (i = 0; i < ehdr->e_phnum; i++, phdp++) {
switch (phdp->p_type) {
case PT_LOAD:
off = (phdp->p_vaddr & align);
size = off + phdp->p_filesz;
ld = _dl_malloc(sizeof(struct load_list));
ld->start = NULL;
ld->size = size;
ld->moff = TRUNC_PG(phdp->p_vaddr);
ld->foff = TRUNC_PG(phdp->p_offset);
ld->prot = PFLAGS(phdp->p_flags);
LDLIST_INSERT(ld);
if ((ld->prot & PROT_WRITE) == 0 ||
ROUND_PG(size) == ROUND_PG(off + phdp->p_memsz))
break;
/* This phdr has a zfod section */
ld = _dl_malloc(sizeof(struct load_list));
ld->start = NULL;
ld->size = ROUND_PG(off + phdp->p_memsz) -
ROUND_PG(size);
ld->moff = TRUNC_PG(phdp->p_vaddr) +
ROUND_PG(size);
ld->foff = -1;
ld->prot = PFLAGS(phdp->p_flags);
LDLIST_INSERT(ld);
break;
case PT_DYNAMIC:
dynp = (Elf_Dyn *)phdp->p_vaddr;
break;
default:
break;
}
}
#define LOFF ((Elf_Addr)lowld->start - lowld->moff)
retry:
for (ld = lowld; ld != NULL; ld = ld->next) {
off_t foff;
int fd, flags;
/*
* We don't want to provide the fd/off hint for anything
* but the first mapping, all other might have
* cache-incoherent aliases and will cause this code to
* loop forever.
*/
if (ld == lowld) {
fd = libfile;
foff = ld->foff;
flags = 0;
} else {
fd = -1;
foff = 0;
flags = MAP_FIXED;
}
ld->start = (void *)(LOFF + ld->moff);
/*
* Magic here.
* The first mquery is done with MAP_FIXED to see if
* the mapping we want is free. If it's not, we redo the
* mquery without MAP_FIXED to get the next free mapping,
* adjust the base mapping address to match this free mapping
* and restart the process again.
*/
ld->start = _dl_mquery(ld->start, ROUND_PG(ld->size), ld->prot,
flags, fd, foff);
if (_dl_mmap_error(ld->start)) {
ld->start = (void *)(LOFF + ld->moff);
ld->start = _dl_mquery(ld->start, ROUND_PG(ld->size),
ld->prot, flags & ~MAP_FIXED, fd, foff);
if (_dl_mmap_error(ld->start))
goto fail;
}
if (ld->start != (void *)(LOFF + ld->moff)) {
lowld->start = ld->start - ld->moff + lowld->moff;
goto retry;
}
/*
* XXX - we need some kind of boundary condition here,
* or fix mquery to not run into the stack
*/
}
for (ld = lowld; ld != NULL; ld = ld->next) {
int fd, flags;
off_t foff;
void *res;
if (ld->foff < 0) {
fd = -1;
foff = 0;
flags = MAP_FIXED|MAP_PRIVATE|MAP_ANON;
} else {
fd = libfile;
foff = ld->foff;
flags = MAP_FIXED|MAP_PRIVATE;
}
res = _dl_mmap(ld->start, ROUND_PG(ld->size), ld->prot, flags,
fd, foff);
if (_dl_mmap_error(res))
goto fail;
/* Zero out everything past the EOF */
if ((ld->prot & PROT_WRITE) != 0 && (ld->size & align) != 0)
_dl_memset((char *)ld->start + ld->size, 0,
_dl_pagesz - (ld->size & align));
load_end = (Elf_Addr)ld->start + ROUND_PG(ld->size);
}
prebind_data = prebind_load_fd(libfile, libname);
_dl_close(libfile);
dynp = (Elf_Dyn *)((unsigned long)dynp + LOFF);
object = _dl_finalize_object(libname, dynp,
(Elf_Phdr *)((char *)lowld->start + ehdr->e_phoff), ehdr->e_phnum,
type, (Elf_Addr)lowld->start, LOFF);
if (object) {
object->prebind_data = prebind_data;
object->load_size = (Elf_Addr)load_end - (Elf_Addr)lowld->start;
object->load_list = lowld;
/* set inode, dev from stat info */
object->dev = sb.st_dev;
object->inode = sb.st_ino;
object->obj_flags |= flags;
_dl_build_sod(object->load_name, &object->sod);
} else {
/* XXX no point. object is never returned NULL */
_dl_load_list_free(lowld);
}
return(object);
fail:
_dl_printf("%s: rtld mmap failed mapping %s.\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_MMAP;
_dl_load_list_free(lowld);
return(0);
}
/*
* 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);
}
