2009-03-04 04:28:35 +01:00
|
|
|
/*
|
2009-10-24 03:11:40 +02:00
|
|
|
* Copyright (C) 2008, 2009 The Android Open Source Project
|
2009-03-04 04:28:35 +01:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* * Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in
|
|
|
|
* the documentation and/or other materials provided with the
|
|
|
|
* distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2012-08-04 01:49:39 +02:00
|
|
|
#include <dlfcn.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
2009-03-04 04:28:35 +01:00
|
|
|
#include <linux/auxvec.h>
|
2012-08-04 01:49:39 +02:00
|
|
|
#include <pthread.h>
|
2009-03-04 04:28:35 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/atomics.h>
|
2012-08-04 01:49:39 +02:00
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-04 01:49:39 +02:00
|
|
|
// Private C library headers.
|
|
|
|
#include <private/bionic_tls.h>
|
2013-02-07 19:14:39 +01:00
|
|
|
#include <private/KernelArgumentBlock.h>
|
2012-08-04 01:49:39 +02:00
|
|
|
#include <private/logd.h>
|
2012-10-12 01:08:51 +02:00
|
|
|
#include <private/ScopedPthreadMutexLocker.h>
|
2009-03-04 04:28:35 +01:00
|
|
|
|
|
|
|
#include "linker.h"
|
|
|
|
#include "linker_debug.h"
|
2010-12-16 19:52:02 +01:00
|
|
|
#include "linker_environ.h"
|
2012-06-18 18:13:49 +02:00
|
|
|
#include "linker_phdr.h"
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2009-06-03 03:27:28 +02:00
|
|
|
/* Assume average path length of 64 and max 8 paths */
|
|
|
|
#define LDPATH_BUFSIZE 512
|
|
|
|
#define LDPATH_MAX 8
|
|
|
|
|
2009-12-31 19:09:10 +01:00
|
|
|
#define LDPRELOAD_BUFSIZE 512
|
|
|
|
#define LDPRELOAD_MAX 8
|
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
/* >>> IMPORTANT NOTE - READ ME BEFORE MODIFYING <<<
|
|
|
|
*
|
|
|
|
* Do NOT use malloc() and friends or pthread_*() code here.
|
|
|
|
* Don't use printf() either; it's caused mysterious memory
|
|
|
|
* corruption in the past.
|
|
|
|
* The linker runs before we bring up libc and it's easiest
|
|
|
|
* to make sure it does not depend on any complex libc features
|
|
|
|
*
|
|
|
|
* open issues / todo:
|
|
|
|
*
|
|
|
|
* - are we doing everything we should for ARM_COPY relocations?
|
|
|
|
* - cleaner error reporting
|
|
|
|
* - after linking, set as much stuff as possible to READONLY
|
|
|
|
* and NOEXEC
|
2012-08-04 01:49:39 +02:00
|
|
|
*/
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
static bool soinfo_link_image(soinfo* si);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-09-12 13:00:55 +02:00
|
|
|
// We can't use malloc(3) in the dynamic linker. We use a linked list of anonymous
|
|
|
|
// maps, each a single page in size. The pages are broken up into as many struct soinfo
|
|
|
|
// objects as will fit, and they're all threaded together on a free list.
|
|
|
|
#define SOINFO_PER_POOL ((PAGE_SIZE - sizeof(soinfo_pool_t*)) / sizeof(soinfo))
|
|
|
|
struct soinfo_pool_t {
|
|
|
|
soinfo_pool_t* next;
|
|
|
|
soinfo info[SOINFO_PER_POOL];
|
|
|
|
};
|
|
|
|
static struct soinfo_pool_t* gSoInfoPools = NULL;
|
|
|
|
static soinfo* gSoInfoFreeList = NULL;
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
static soinfo* solist = &libdl_info;
|
|
|
|
static soinfo* sonext = &libdl_info;
|
|
|
|
static soinfo* somain; /* main process, always the one after libdl_info */
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
static const char* const gSoPaths[] = {
|
|
|
|
"/vendor/lib",
|
|
|
|
"/system/lib",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static char gLdPathsBuffer[LDPATH_BUFSIZE];
|
|
|
|
static const char* gLdPaths[LDPATH_MAX + 1];
|
2009-06-03 03:27:28 +02:00
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
static char gLdPreloadsBuffer[LDPRELOAD_BUFSIZE];
|
|
|
|
static const char* gLdPreloadNames[LDPRELOAD_MAX + 1];
|
2009-12-31 19:09:10 +01:00
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
static soinfo* gLdPreloads[LDPRELOAD_MAX + 1];
|
2009-12-31 19:09:10 +01:00
|
|
|
|
2013-03-06 03:47:58 +01:00
|
|
|
__LIBC_HIDDEN__ int gLdDebugVerbosity;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-14 23:07:59 +02:00
|
|
|
enum RelocationKind {
|
|
|
|
kRelocAbsolute = 0,
|
|
|
|
kRelocRelative,
|
|
|
|
kRelocCopy,
|
|
|
|
kRelocSymbol,
|
|
|
|
kRelocMax
|
|
|
|
};
|
2010-12-16 19:52:02 +01:00
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
#if STATS
|
2012-08-14 23:07:59 +02:00
|
|
|
struct linker_stats_t {
|
|
|
|
int count[kRelocMax];
|
|
|
|
};
|
|
|
|
|
|
|
|
static linker_stats_t linker_stats;
|
|
|
|
|
|
|
|
static void count_relocation(RelocationKind kind) {
|
|
|
|
++linker_stats.count[kind];
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void count_relocation(RelocationKind) {
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if COUNT_PAGES
|
2012-08-14 23:07:59 +02:00
|
|
|
static unsigned bitmask[4096];
|
|
|
|
#define MARK(offset) \
|
|
|
|
do { \
|
|
|
|
bitmask[((offset) >> 12) >> 3] |= (1 << (((offset) >> 12) & 7)); \
|
|
|
|
} while(0)
|
|
|
|
#else
|
|
|
|
#define MARK(x) do {} while (0)
|
2009-03-04 04:28:35 +01:00
|
|
|
#endif
|
|
|
|
|
2012-08-04 01:49:39 +02:00
|
|
|
// You shouldn't try to call memory-allocating functions in the dynamic linker.
|
|
|
|
// Guard against the most obvious ones.
|
|
|
|
#define DISALLOW_ALLOCATION(return_type, name, ...) \
|
|
|
|
return_type name __VA_ARGS__ \
|
|
|
|
{ \
|
|
|
|
const char* msg = "ERROR: " #name " called from the dynamic linker!\n"; \
|
|
|
|
__libc_android_log_write(ANDROID_LOG_FATAL, "linker", msg); \
|
2012-10-31 13:39:27 +01:00
|
|
|
write(2, msg, strlen(msg)); \
|
2012-08-04 01:49:39 +02:00
|
|
|
abort(); \
|
|
|
|
}
|
|
|
|
#define UNUSED __attribute__((unused))
|
|
|
|
DISALLOW_ALLOCATION(void*, malloc, (size_t u UNUSED));
|
|
|
|
DISALLOW_ALLOCATION(void, free, (void* u UNUSED));
|
|
|
|
DISALLOW_ALLOCATION(void*, realloc, (void* u1 UNUSED, size_t u2 UNUSED));
|
|
|
|
DISALLOW_ALLOCATION(void*, calloc, (size_t u1 UNUSED, size_t u2 UNUSED));
|
2009-05-21 03:28:09 +02:00
|
|
|
|
2009-05-30 02:30:25 +02:00
|
|
|
static char tmp_err_buf[768];
|
2009-05-21 03:28:09 +02:00
|
|
|
static char __linker_dl_err_buf[768];
|
|
|
|
|
2013-03-06 03:47:58 +01:00
|
|
|
char* linker_get_error_buffer() {
|
2012-10-17 00:54:46 +02:00
|
|
|
return &__linker_dl_err_buf[0];
|
2009-05-21 03:28:09 +02:00
|
|
|
}
|
|
|
|
|
2013-03-06 03:47:58 +01:00
|
|
|
size_t linker_get_error_buffer_size() {
|
|
|
|
return sizeof(__linker_dl_err_buf);
|
|
|
|
}
|
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
/*
|
|
|
|
* This function is an empty stub where GDB locates a breakpoint to get notified
|
|
|
|
* about linker activity.
|
|
|
|
*/
|
2012-10-17 00:54:46 +02:00
|
|
|
extern "C" void __attribute__((noinline)) __attribute__((visibility("default"))) rtld_db_dlactivity();
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-14 23:07:59 +02:00
|
|
|
static r_debug _r_debug = {1, NULL, &rtld_db_dlactivity,
|
2009-03-04 04:28:35 +01:00
|
|
|
RT_CONSISTENT, 0};
|
2012-08-14 23:07:59 +02:00
|
|
|
static link_map* r_debug_tail = 0;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-10-12 01:08:51 +02:00
|
|
|
static pthread_mutex_t gDebugMutex = PTHREAD_MUTEX_INITIALIZER;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-14 23:07:59 +02:00
|
|
|
static void insert_soinfo_into_debug_map(soinfo * info) {
|
|
|
|
// Copy the necessary fields into the debug structure.
|
|
|
|
link_map* map = &(info->linkmap);
|
2009-03-04 04:28:35 +01:00
|
|
|
map->l_addr = info->base;
|
|
|
|
map->l_name = (char*) info->name;
|
2009-07-03 13:40:32 +02:00
|
|
|
map->l_ld = (uintptr_t)info->dynamic;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
|
|
|
/* Stick the new library at the end of the list.
|
|
|
|
* gdb tends to care more about libc than it does
|
|
|
|
* about leaf libraries, and ordering it this way
|
|
|
|
* reduces the back-and-forth over the wire.
|
|
|
|
*/
|
|
|
|
if (r_debug_tail) {
|
|
|
|
r_debug_tail->l_next = map;
|
|
|
|
map->l_prev = r_debug_tail;
|
|
|
|
map->l_next = 0;
|
|
|
|
} else {
|
|
|
|
_r_debug.r_map = map;
|
|
|
|
map->l_prev = 0;
|
|
|
|
map->l_next = 0;
|
|
|
|
}
|
|
|
|
r_debug_tail = map;
|
|
|
|
}
|
|
|
|
|
2012-08-14 23:07:59 +02:00
|
|
|
static void remove_soinfo_from_debug_map(soinfo* info) {
|
|
|
|
link_map* map = &(info->linkmap);
|
2009-03-25 03:02:00 +01:00
|
|
|
|
2012-08-14 23:07:59 +02:00
|
|
|
if (r_debug_tail == map) {
|
2009-03-25 03:02:00 +01:00
|
|
|
r_debug_tail = map->l_prev;
|
2012-08-14 23:07:59 +02:00
|
|
|
}
|
2009-03-25 03:02:00 +01:00
|
|
|
|
2012-08-14 23:07:59 +02:00
|
|
|
if (map->l_prev) {
|
|
|
|
map->l_prev->l_next = map->l_next;
|
|
|
|
}
|
|
|
|
if (map->l_next) {
|
|
|
|
map->l_next->l_prev = map->l_prev;
|
|
|
|
}
|
2009-03-25 03:02:00 +01:00
|
|
|
}
|
|
|
|
|
2012-08-14 23:07:59 +02:00
|
|
|
static void notify_gdb_of_load(soinfo* info) {
|
2009-03-04 04:28:35 +01:00
|
|
|
if (info->flags & FLAG_EXE) {
|
|
|
|
// GDB already knows about the main executable
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-10-12 01:08:51 +02:00
|
|
|
ScopedPthreadMutexLocker locker(&gDebugMutex);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
|
|
|
_r_debug.r_state = RT_ADD;
|
|
|
|
rtld_db_dlactivity();
|
|
|
|
|
|
|
|
insert_soinfo_into_debug_map(info);
|
|
|
|
|
|
|
|
_r_debug.r_state = RT_CONSISTENT;
|
|
|
|
rtld_db_dlactivity();
|
2009-03-25 03:02:00 +01:00
|
|
|
}
|
|
|
|
|
2012-08-14 23:07:59 +02:00
|
|
|
static void notify_gdb_of_unload(soinfo* info) {
|
2009-03-25 03:02:00 +01:00
|
|
|
if (info->flags & FLAG_EXE) {
|
|
|
|
// GDB already knows about the main executable
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-10-12 01:08:51 +02:00
|
|
|
ScopedPthreadMutexLocker locker(&gDebugMutex);
|
2009-03-25 03:02:00 +01:00
|
|
|
|
|
|
|
_r_debug.r_state = RT_DELETE;
|
|
|
|
rtld_db_dlactivity();
|
|
|
|
|
|
|
|
remove_soinfo_from_debug_map(info);
|
|
|
|
|
|
|
|
_r_debug.r_state = RT_CONSISTENT;
|
|
|
|
rtld_db_dlactivity();
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-10-30 01:37:13 +01:00
|
|
|
void notify_gdb_of_libraries() {
|
2009-03-04 04:28:35 +01:00
|
|
|
_r_debug.r_state = RT_ADD;
|
|
|
|
rtld_db_dlactivity();
|
|
|
|
_r_debug.r_state = RT_CONSISTENT;
|
|
|
|
rtld_db_dlactivity();
|
|
|
|
}
|
|
|
|
|
2012-09-12 13:00:55 +02:00
|
|
|
static bool ensure_free_list_non_empty() {
|
|
|
|
if (gSoInfoFreeList != NULL) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Allocate a new pool.
|
|
|
|
soinfo_pool_t* pool = reinterpret_cast<soinfo_pool_t*>(mmap(NULL, sizeof(*pool),
|
|
|
|
PROT_READ|PROT_WRITE,
|
|
|
|
MAP_PRIVATE|MAP_ANONYMOUS, 0, 0));
|
|
|
|
if (pool == MAP_FAILED) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add the pool to our list of pools.
|
|
|
|
pool->next = gSoInfoPools;
|
|
|
|
gSoInfoPools = pool;
|
|
|
|
|
|
|
|
// Chain the entries in the new pool onto the free list.
|
|
|
|
gSoInfoFreeList = &pool->info[0];
|
|
|
|
soinfo* next = NULL;
|
|
|
|
for (int i = SOINFO_PER_POOL - 1; i >= 0; --i) {
|
|
|
|
pool->info[i].next = next;
|
|
|
|
next = &pool->info[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
static void set_soinfo_pool_protection(int protection) {
|
|
|
|
for (soinfo_pool_t* p = gSoInfoPools; p != NULL; p = p->next) {
|
|
|
|
if (mprotect(p, sizeof(*p), protection) == -1) {
|
|
|
|
abort(); // Can't happen.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-12 13:00:55 +02:00
|
|
|
static soinfo* soinfo_alloc(const char* name) {
|
|
|
|
if (strlen(name) >= SOINFO_NAME_LEN) {
|
|
|
|
DL_ERR("library name \"%s\" too long", name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ensure_free_list_non_empty()) {
|
|
|
|
DL_ERR("out of memory when loading \"%s\"", name);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-09-12 13:00:55 +02:00
|
|
|
// Take the head element off the free list.
|
|
|
|
soinfo* si = gSoInfoFreeList;
|
|
|
|
gSoInfoFreeList = gSoInfoFreeList->next;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-09-12 13:00:55 +02:00
|
|
|
// Initialize the new element.
|
|
|
|
memset(si, 0, sizeof(soinfo));
|
|
|
|
strlcpy(si->name, name, sizeof(si->name));
|
|
|
|
sonext->next = si;
|
|
|
|
sonext = si;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("name %s: allocated soinfo @ %p\n", name, si);
|
2012-09-12 13:00:55 +02:00
|
|
|
return si;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-08-04 01:49:39 +02:00
|
|
|
static void soinfo_free(soinfo* si)
|
2009-03-04 04:28:35 +01:00
|
|
|
{
|
2012-08-04 01:49:39 +02:00
|
|
|
if (si == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
soinfo *prev = NULL, *trav;
|
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("name %s: freeing soinfo @ %p\n", si->name, si);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
for (trav = solist; trav != NULL; trav = trav->next) {
|
2009-03-04 04:28:35 +01:00
|
|
|
if (trav == si)
|
|
|
|
break;
|
|
|
|
prev = trav;
|
|
|
|
}
|
|
|
|
if (trav == NULL) {
|
2013-03-01 00:58:45 +01:00
|
|
|
/* si was not in solist */
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("name \"%s\" is not in solist!", si->name);
|
2009-03-04 04:28:35 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-12-16 19:52:02 +01:00
|
|
|
/* prev will never be NULL, because the first entry in solist is
|
2009-03-04 04:28:35 +01:00
|
|
|
always the static libdl_info.
|
|
|
|
*/
|
|
|
|
prev->next = si->next;
|
2013-03-01 00:58:45 +01:00
|
|
|
if (si == sonext) {
|
|
|
|
sonext = prev;
|
|
|
|
}
|
2012-09-12 13:00:55 +02:00
|
|
|
si->next = gSoInfoFreeList;
|
|
|
|
gSoInfoFreeList = si;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-12-20 23:42:14 +01:00
|
|
|
|
|
|
|
static void parse_path(const char* path, const char* delimiters,
|
|
|
|
const char** array, char* buf, size_t buf_size, size_t max_count) {
|
|
|
|
if (path == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t len = strlcpy(buf, path, buf_size);
|
|
|
|
|
|
|
|
size_t i = 0;
|
|
|
|
char* buf_p = buf;
|
|
|
|
while (i < max_count && (array[i] = strsep(&buf_p, delimiters))) {
|
|
|
|
if (*array[i] != '\0') {
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Forget the last path if we had to truncate; this occurs if the 2nd to
|
|
|
|
// last char isn't '\0' (i.e. wasn't originally a delimiter).
|
|
|
|
if (i > 0 && len >= buf_size && buf[buf_size - 2] != '\0') {
|
|
|
|
array[i - 1] = NULL;
|
|
|
|
} else {
|
|
|
|
array[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_LD_LIBRARY_PATH(const char* path) {
|
|
|
|
parse_path(path, ":", gLdPaths,
|
|
|
|
gLdPathsBuffer, sizeof(gLdPathsBuffer), LDPATH_MAX);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_LD_PRELOAD(const char* path) {
|
|
|
|
// We have historically supported ':' as well as ' ' in LD_PRELOAD.
|
|
|
|
parse_path(path, " :", gLdPreloadNames,
|
|
|
|
gLdPreloadsBuffer, sizeof(gLdPreloadsBuffer), LDPRELOAD_MAX);
|
|
|
|
}
|
|
|
|
|
2012-08-04 01:49:39 +02:00
|
|
|
#ifdef ANDROID_ARM_LINKER
|
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
/* For a given PC, find the .so that it belongs to.
|
|
|
|
* Returns the base address of the .ARM.exidx section
|
|
|
|
* for that .so, and the number of 8-byte entries
|
|
|
|
* in that section (via *pcount).
|
|
|
|
*
|
|
|
|
* Intended to be called by libc's __gnu_Unwind_Find_exidx().
|
|
|
|
*
|
2012-10-12 01:08:51 +02:00
|
|
|
* This function is exposed via dlfcn.cpp and libdl.so.
|
2009-03-04 04:28:35 +01:00
|
|
|
*/
|
|
|
|
_Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr pc, int *pcount)
|
|
|
|
{
|
|
|
|
soinfo *si;
|
|
|
|
unsigned addr = (unsigned)pc;
|
|
|
|
|
2011-11-12 00:53:17 +01:00
|
|
|
for (si = solist; si != 0; si = si->next){
|
|
|
|
if ((addr >= si->base) && (addr < (si->base + si->size))) {
|
|
|
|
*pcount = si->ARM_exidx_count;
|
2012-05-31 13:20:36 +02:00
|
|
|
return (_Unwind_Ptr)si->ARM_exidx;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
*pcount = 0;
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-08-04 01:49:39 +02:00
|
|
|
|
2012-07-31 21:07:22 +02:00
|
|
|
#elif defined(ANDROID_X86_LINKER) || defined(ANDROID_MIPS_LINKER)
|
2012-08-04 01:49:39 +02:00
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
/* Here, we only have to provide a callback to iterate across all the
|
|
|
|
* loaded libraries. gcc_eh does the rest. */
|
|
|
|
int
|
2012-08-14 23:07:59 +02:00
|
|
|
dl_iterate_phdr(int (*cb)(dl_phdr_info *info, size_t size, void *data),
|
2009-03-04 04:28:35 +01:00
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
int rv = 0;
|
2012-08-14 23:07:59 +02:00
|
|
|
for (soinfo* si = solist; si != NULL; si = si->next) {
|
|
|
|
dl_phdr_info dl_info;
|
2009-03-04 04:28:35 +01:00
|
|
|
dl_info.dlpi_addr = si->linkmap.l_addr;
|
|
|
|
dl_info.dlpi_name = si->linkmap.l_name;
|
|
|
|
dl_info.dlpi_phdr = si->phdr;
|
|
|
|
dl_info.dlpi_phnum = si->phnum;
|
2012-08-14 23:07:59 +02:00
|
|
|
rv = cb(&dl_info, sizeof(dl_phdr_info), data);
|
|
|
|
if (rv != 0) {
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
2012-08-14 23:07:59 +02:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
2012-08-04 01:49:39 +02:00
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
#endif
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
static Elf32_Sym* soinfo_elf_lookup(soinfo* si, unsigned hash, const char* name) {
|
|
|
|
Elf32_Sym* s;
|
|
|
|
Elf32_Sym* symtab = si->symtab;
|
|
|
|
const char* strtab = si->strtab;
|
2009-03-04 04:28:35 +01:00
|
|
|
unsigned n;
|
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(LOOKUP, "SEARCH %s in %s@0x%08x %08x %d\n",
|
2009-03-04 04:28:35 +01:00
|
|
|
name, si->name, si->base, hash, hash % si->nbucket);
|
|
|
|
n = hash % si->nbucket;
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
for (n = si->bucket[hash % si->nbucket]; n != 0; n = si->chain[n]) {
|
2009-03-04 04:28:35 +01:00
|
|
|
s = symtab + n;
|
2013-03-01 00:58:45 +01:00
|
|
|
if (strcmp(strtab + s->st_name, name)) continue;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2009-10-26 20:05:23 +01:00
|
|
|
/* only concern ourselves with global and weak symbol definitions */
|
2009-03-04 04:28:35 +01:00
|
|
|
switch(ELF32_ST_BIND(s->st_info)){
|
|
|
|
case STB_GLOBAL:
|
2009-10-26 20:05:23 +01:00
|
|
|
case STB_WEAK:
|
2013-03-01 00:58:45 +01:00
|
|
|
if (s->st_shndx == SHN_UNDEF) {
|
2012-07-05 09:21:07 +02:00
|
|
|
continue;
|
2013-03-01 00:58:45 +01:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(LOOKUP, "FOUND %s in %s (%08x) %d\n",
|
2009-03-04 04:28:35 +01:00
|
|
|
name, si->name, s->st_value, s->st_size);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-24 03:11:40 +02:00
|
|
|
return NULL;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
static unsigned elfhash(const char* _name) {
|
|
|
|
const unsigned char* name = (const unsigned char*) _name;
|
2009-03-04 04:28:35 +01:00
|
|
|
unsigned h = 0, g;
|
|
|
|
|
|
|
|
while(*name) {
|
|
|
|
h = (h << 4) + *name++;
|
|
|
|
g = h & 0xf0000000;
|
|
|
|
h ^= g;
|
|
|
|
h ^= g >> 24;
|
|
|
|
}
|
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
static Elf32_Sym* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi, soinfo* needed[]) {
|
2009-10-24 03:11:40 +02:00
|
|
|
unsigned elf_hash = elfhash(name);
|
2013-03-01 00:58:45 +01:00
|
|
|
Elf32_Sym* s = NULL;
|
2009-09-29 04:38:04 +02:00
|
|
|
|
2012-10-31 10:55:51 +01:00
|
|
|
if (si != NULL && somain != NULL) {
|
2012-08-30 12:48:32 +02:00
|
|
|
|
|
|
|
/*
|
2012-10-31 10:55:51 +01:00
|
|
|
* Local scope is executable scope. Just start looking into it right away
|
|
|
|
* for the shortcut.
|
2012-08-30 12:48:32 +02:00
|
|
|
*/
|
|
|
|
|
2012-10-31 10:55:51 +01:00
|
|
|
if (si == somain) {
|
|
|
|
s = soinfo_elf_lookup(si, elf_hash, name);
|
2012-08-30 12:48:32 +02:00
|
|
|
if (s != NULL) {
|
2012-10-31 10:55:51 +01:00
|
|
|
*lsi = si;
|
2012-08-30 12:48:32 +02:00
|
|
|
goto done;
|
|
|
|
}
|
2012-10-31 10:55:51 +01:00
|
|
|
} else {
|
|
|
|
/* Order of symbol lookup is controlled by DT_SYMBOLIC flag */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this object was built with symbolic relocations disabled, the
|
|
|
|
* first place to look to resolve external references is the main
|
|
|
|
* executable.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!si->has_DT_SYMBOLIC) {
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("%s: looking up %s in executable %s\n",
|
|
|
|
si->name, name, somain->name);
|
2012-10-31 10:55:51 +01:00
|
|
|
s = soinfo_elf_lookup(somain, elf_hash, name);
|
|
|
|
if (s != NULL) {
|
|
|
|
*lsi = somain;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
2012-08-30 12:48:32 +02:00
|
|
|
|
2012-10-31 10:55:51 +01:00
|
|
|
/* Look for symbols in the local scope (the object who is
|
|
|
|
* searching). This happens with C++ templates on i386 for some
|
|
|
|
* reason.
|
|
|
|
*
|
|
|
|
* Notes on weak symbols:
|
|
|
|
* The ELF specs are ambiguous about treatment of weak definitions in
|
|
|
|
* dynamic linking. Some systems return the first definition found
|
|
|
|
* and some the first non-weak definition. This is system dependent.
|
|
|
|
* Here we return the first definition found for simplicity. */
|
|
|
|
|
|
|
|
s = soinfo_elf_lookup(si, elf_hash, name);
|
|
|
|
if (s != NULL) {
|
|
|
|
*lsi = si;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this object was built with -Bsymbolic and symbol is not found
|
|
|
|
* in the local scope, try to find the symbol in the main executable.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (si->has_DT_SYMBOLIC) {
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("%s: looking up %s in executable %s after local scope\n",
|
|
|
|
si->name, name, somain->name);
|
2012-10-31 10:55:51 +01:00
|
|
|
s = soinfo_elf_lookup(somain, elf_hash, name);
|
|
|
|
if (s != NULL) {
|
|
|
|
*lsi = somain;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
2012-08-30 12:48:32 +02:00
|
|
|
}
|
2012-08-24 22:25:51 +02:00
|
|
|
}
|
2009-09-29 04:38:04 +02:00
|
|
|
|
2009-12-31 19:09:10 +01:00
|
|
|
/* Next, look for it in the preloads list */
|
2013-03-01 00:58:45 +01:00
|
|
|
for (int i = 0; gLdPreloads[i] != NULL; i++) {
|
|
|
|
s = soinfo_elf_lookup(gLdPreloads[i], elf_hash, name);
|
|
|
|
if (s != NULL) {
|
|
|
|
*lsi = gLdPreloads[i];
|
2009-12-31 19:09:10 +01:00
|
|
|
goto done;
|
2012-08-30 12:48:32 +02:00
|
|
|
}
|
2009-12-31 19:09:10 +01:00
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
for (int i = 0; needed[i] != NULL; i++) {
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("%s: looking up %s in %s\n",
|
|
|
|
si->name, name, needed[i]->name);
|
2012-08-30 12:48:32 +02:00
|
|
|
s = soinfo_elf_lookup(needed[i], elf_hash, name);
|
|
|
|
if (s != NULL) {
|
|
|
|
*lsi = needed[i];
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
goto done;
|
2012-08-30 12:48:32 +02:00
|
|
|
}
|
2009-09-29 04:38:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
2013-03-01 00:58:45 +01:00
|
|
|
if (s != NULL) {
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(LOOKUP, "si %s sym %s s->st_value = 0x%08x, "
|
2012-06-18 23:38:46 +02:00
|
|
|
"found in %s, base = 0x%08x, load bias = 0x%08x\n",
|
2012-11-02 20:37:13 +01:00
|
|
|
si->name, name, s->st_value,
|
2012-08-30 12:48:32 +02:00
|
|
|
(*lsi)->name, (*lsi)->base, (*lsi)->load_bias);
|
2009-09-29 04:38:04 +02:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2009-10-24 03:11:40 +02:00
|
|
|
return NULL;
|
2009-09-29 04:38:04 +02:00
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
/* This is used by dlsym(3). It performs symbol lookup only within the
|
2009-09-29 04:38:04 +02:00
|
|
|
specified soinfo object and not in any of its dependencies.
|
2013-03-01 00:58:45 +01:00
|
|
|
|
|
|
|
TODO: Only looking in the specified soinfo seems wrong. dlsym(3) says
|
|
|
|
that it should do a breadth first search through the dependency
|
|
|
|
tree. This agrees with the ELF spec (aka System V Application
|
|
|
|
Binary Interface) where in Chapter 5 it discuss resolving "Shared
|
|
|
|
Object Dependencies" in breadth first search order.
|
2009-09-29 04:38:04 +02:00
|
|
|
*/
|
2013-03-01 00:58:45 +01:00
|
|
|
Elf32_Sym* dlsym_handle_lookup(soinfo* si, const char* name)
|
2009-03-04 04:28:35 +01:00
|
|
|
{
|
2012-06-12 16:25:37 +02:00
|
|
|
return soinfo_elf_lookup(si, elfhash(name), name);
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
/* This is used by dlsym(3) to performs a global symbol lookup. If the
|
|
|
|
start value is null (for RTLD_DEFAULT), the search starts at the
|
|
|
|
beginning of the global solist. Otherwise the search starts at the
|
|
|
|
specified soinfo (for RTLD_NEXT).
|
2009-09-29 04:38:04 +02:00
|
|
|
*/
|
2013-03-01 00:58:45 +01:00
|
|
|
Elf32_Sym* dlsym_linear_lookup(const char* name, soinfo** found, soinfo* start) {
|
2012-12-20 23:42:14 +01:00
|
|
|
unsigned elf_hash = elfhash(name);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-12-20 23:42:14 +01:00
|
|
|
if (start == NULL) {
|
|
|
|
start = solist;
|
|
|
|
}
|
2009-12-31 19:17:56 +01:00
|
|
|
|
2012-12-20 23:42:14 +01:00
|
|
|
Elf32_Sym* s = NULL;
|
|
|
|
for (soinfo* si = start; (s == NULL) && (si != NULL); si = si->next) {
|
|
|
|
s = soinfo_elf_lookup(si, elf_hash, name);
|
|
|
|
if (s != NULL) {
|
|
|
|
*found = si;
|
|
|
|
break;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
2012-12-20 23:42:14 +01:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-12-20 23:42:14 +01:00
|
|
|
if (s != NULL) {
|
|
|
|
TRACE_TYPE(LOOKUP, "%s s->st_value = 0x%08x, found->base = 0x%08x\n",
|
|
|
|
name, s->st_value, (*found)->base);
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-12-20 23:42:14 +01:00
|
|
|
return s;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
soinfo* find_containing_library(const void* addr) {
|
|
|
|
for (soinfo* si = solist; si != NULL; si = si->next) {
|
|
|
|
if ((unsigned)addr >= si->base && (unsigned)addr - si->base < si->size) {
|
2009-12-31 19:17:40 +01:00
|
|
|
return si;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
Elf32_Sym* dladdr_find_symbol(soinfo* si, const void* addr) {
|
2009-12-31 19:17:40 +01:00
|
|
|
unsigned int i;
|
|
|
|
unsigned soaddr = (unsigned)addr - si->base;
|
|
|
|
|
|
|
|
/* Search the library's symbol table for any defined symbol which
|
|
|
|
* contains this address */
|
2013-03-01 00:58:45 +01:00
|
|
|
for (i=0; i<si->nchain; i++) {
|
2009-12-31 19:17:40 +01:00
|
|
|
Elf32_Sym *sym = &si->symtab[i];
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
if (sym->st_shndx != SHN_UNDEF &&
|
2009-12-31 19:17:40 +01:00
|
|
|
soaddr >= sym->st_value &&
|
|
|
|
soaddr < sym->st_value + sym->st_size) {
|
|
|
|
return sym;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
#if 0
|
2013-03-01 00:58:45 +01:00
|
|
|
static void dump(soinfo* si)
|
2009-03-04 04:28:35 +01:00
|
|
|
{
|
2013-03-01 00:58:45 +01:00
|
|
|
Elf32_Sym* s = si->symtab;
|
|
|
|
for (unsigned n = 0; n < si->nchain; n++) {
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("%04d> %08x: %02x %04x %08x %08x %s\n", n, s,
|
2009-03-04 04:28:35 +01:00
|
|
|
s->st_info, s->st_shndx, s->st_value, s->st_size,
|
|
|
|
si->strtab + s->st_name);
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
static int open_library_on_path(const char* name, const char* const paths[]) {
|
|
|
|
char buf[512];
|
|
|
|
for (size_t i = 0; paths[i] != NULL; ++i) {
|
2013-01-18 03:36:06 +01:00
|
|
|
int n = __libc_format_buffer(buf, sizeof(buf), "%s/%s", paths[i], name);
|
2012-10-31 22:20:03 +01:00
|
|
|
if (n < 0 || n >= static_cast<int>(sizeof(buf))) {
|
2012-11-05 18:11:43 +01:00
|
|
|
PRINT("Warning: ignoring very long library path: %s/%s\n", paths[i], name);
|
2012-10-31 22:20:03 +01:00
|
|
|
continue;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
2012-10-31 22:20:03 +01:00
|
|
|
int fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC));
|
|
|
|
if (fd != -1) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
static int open_library(const char* name) {
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ opening %s ]\n", name);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
// If the name contains a slash, we should attempt to open it directly and not search the paths.
|
|
|
|
if (strchr(name, '/') != NULL) {
|
2012-11-02 06:59:19 +01:00
|
|
|
int fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_CLOEXEC));
|
|
|
|
if (fd != -1) {
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
// ...but nvidia binary blobs (at least) rely on this behavior, so fall through for now.
|
2012-10-31 22:20:03 +01:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
// Otherwise we try LD_LIBRARY_PATH first, and fall back to the built-in well known paths.
|
|
|
|
int fd = open_library_on_path(name, gLdPaths);
|
|
|
|
if (fd == -1) {
|
|
|
|
fd = open_library_on_path(name, gSoPaths);
|
|
|
|
}
|
|
|
|
return fd;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
static soinfo* load_library(const char* name) {
|
2012-08-04 01:49:39 +02:00
|
|
|
// Open the file.
|
2013-03-06 03:47:58 +01:00
|
|
|
int fd = open_library(name);
|
|
|
|
if (fd == -1) {
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("library \"%s\" not found", name);
|
2009-03-04 04:28:35 +01:00
|
|
|
return NULL;
|
2009-05-21 03:28:09 +02:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2013-03-06 03:47:58 +01:00
|
|
|
// Read the ELF header and load the segments.
|
|
|
|
ElfReader elf_reader(name, fd);
|
|
|
|
if (!elf_reader.Load()) {
|
2012-08-04 01:49:39 +02:00
|
|
|
return NULL;
|
2012-06-18 18:13:49 +02:00
|
|
|
}
|
|
|
|
|
2013-03-06 03:47:58 +01:00
|
|
|
const char* bname = strrchr(name, '/');
|
|
|
|
soinfo* si = soinfo_alloc(bname ? bname + 1 : name);
|
|
|
|
if (si == NULL) {
|
2012-08-04 01:49:39 +02:00
|
|
|
return NULL;
|
2012-06-18 18:13:49 +02:00
|
|
|
}
|
2013-03-06 03:47:58 +01:00
|
|
|
si->base = elf_reader.load_start();
|
|
|
|
si->size = elf_reader.load_size();
|
|
|
|
si->load_bias = elf_reader.load_bias();
|
|
|
|
si->flags = 0;
|
|
|
|
si->entry = 0;
|
|
|
|
si->dynamic = NULL;
|
|
|
|
si->phnum = elf_reader.phdr_count();
|
|
|
|
si->phdr = elf_reader.loaded_phdr();
|
|
|
|
return si;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
static soinfo *find_loaded_library(const char *name)
|
2009-03-04 04:28:35 +01:00
|
|
|
{
|
|
|
|
soinfo *si;
|
2010-07-22 01:18:21 +02:00
|
|
|
const char *bname;
|
|
|
|
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
// TODO: don't use basename only for determining libraries
|
|
|
|
// http://code.google.com/p/android/issues/detail?id=6670
|
|
|
|
|
|
|
|
bname = strrchr(name, '/');
|
|
|
|
bname = bname ? bname + 1 : name;
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
for (si = solist; si != NULL; si = si->next) {
|
|
|
|
if (!strcmp(bname, si->name)) {
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
return si;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
static soinfo* find_library_internal(const char* name) {
|
|
|
|
if (name == NULL) {
|
|
|
|
return somain;
|
|
|
|
}
|
|
|
|
|
|
|
|
soinfo* si = find_loaded_library(name);
|
|
|
|
if (si != NULL) {
|
|
|
|
if (si->flags & FLAG_LINKED) {
|
|
|
|
return si;
|
|
|
|
}
|
|
|
|
DL_ERR("OOPS: recursive link to \"%s\"", si->name);
|
|
|
|
return NULL;
|
|
|
|
}
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ '%s' has not been loaded yet. Locating...]\n", name);
|
2012-11-01 23:16:56 +01:00
|
|
|
si = load_library(name);
|
2012-12-20 23:42:14 +01:00
|
|
|
if (si == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// At this point we know that whatever is loaded @ base is a valid ELF
|
|
|
|
// shared library whose segments are properly mapped in.
|
|
|
|
TRACE("[ init_library base=0x%08x sz=0x%08x name='%s') ]\n",
|
|
|
|
si->base, si->size, si->name);
|
|
|
|
|
|
|
|
if (!soinfo_link_image(si)) {
|
|
|
|
munmap(reinterpret_cast<void*>(si->base), si->size);
|
|
|
|
soinfo_free(si);
|
|
|
|
return NULL;
|
2012-11-01 23:16:56 +01:00
|
|
|
}
|
2010-07-22 01:18:21 +02:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
return si;
|
|
|
|
}
|
|
|
|
|
|
|
|
static soinfo* find_library(const char* name) {
|
|
|
|
soinfo* si = find_library_internal(name);
|
|
|
|
if (si != NULL) {
|
|
|
|
si->refcount++;
|
|
|
|
}
|
|
|
|
return si;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int soinfo_unload(soinfo* si) {
|
|
|
|
if (si->refcount == 1) {
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("unloading '%s'\n", si->name);
|
2012-11-01 23:16:56 +01:00
|
|
|
si->CallDestructors();
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
for (Elf32_Dyn* d = si->dynamic; d->d_tag != DT_NEEDED; ++d) {
|
|
|
|
if (d->d_tag == DT_NEEDED) {
|
|
|
|
const char* library_name = si->strtab + d->d_un.d_val;
|
|
|
|
soinfo* lsi = find_loaded_library(library_name);
|
2012-11-01 23:16:56 +01:00
|
|
|
if (lsi != NULL) {
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("%s needs to unload %s\n", si->name, lsi->name);
|
2012-11-01 23:16:56 +01:00
|
|
|
soinfo_unload(lsi);
|
|
|
|
} else {
|
|
|
|
// TODO: should we return -1 in this case?
|
|
|
|
DL_ERR("\"%s\": could not unload dependent library", si->name);
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
2012-11-01 23:16:56 +01:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
munmap(reinterpret_cast<void*>(si->base), si->size);
|
|
|
|
notify_gdb_of_unload(si);
|
|
|
|
soinfo_free(si);
|
|
|
|
si->refcount = 0;
|
|
|
|
} else {
|
|
|
|
si->refcount--;
|
2012-11-05 18:11:43 +01:00
|
|
|
TRACE("not unloading '%s', decrementing refcount to %d\n", si->name, si->refcount);
|
2012-11-01 23:16:56 +01:00
|
|
|
}
|
|
|
|
return 0;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-12-20 23:42:14 +01:00
|
|
|
void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) {
|
|
|
|
if (!get_AT_SECURE()) {
|
|
|
|
parse_LD_LIBRARY_PATH(ld_library_path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-19 00:57:55 +01:00
|
|
|
soinfo* do_dlopen(const char* name, int flags) {
|
|
|
|
if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL)) != 0) {
|
|
|
|
DL_ERR("invalid flags to dlopen: %x", flags);
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-11-01 23:16:56 +01:00
|
|
|
set_soinfo_pool_protection(PROT_READ | PROT_WRITE);
|
|
|
|
soinfo* si = find_library(name);
|
|
|
|
if (si != NULL) {
|
|
|
|
si->CallConstructors();
|
|
|
|
}
|
|
|
|
set_soinfo_pool_protection(PROT_READ);
|
|
|
|
return si;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
int do_dlclose(soinfo* si) {
|
|
|
|
set_soinfo_pool_protection(PROT_READ | PROT_WRITE);
|
|
|
|
int result = soinfo_unload(si);
|
|
|
|
set_soinfo_pool_protection(PROT_READ);
|
|
|
|
return result;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: don't use unsigned for addrs below. It works, but is not
|
|
|
|
* ideal. They should probably be either uint32_t, Elf32_Addr, or unsigned
|
|
|
|
* long.
|
|
|
|
*/
|
2013-03-01 00:58:45 +01:00
|
|
|
static int soinfo_relocate(soinfo* si, Elf32_Rel* rel, unsigned count,
|
|
|
|
soinfo* needed[])
|
2009-03-04 04:28:35 +01:00
|
|
|
{
|
2013-03-01 00:58:45 +01:00
|
|
|
Elf32_Sym* symtab = si->symtab;
|
|
|
|
const char* strtab = si->strtab;
|
|
|
|
Elf32_Sym* s;
|
|
|
|
Elf32_Rel* start = rel;
|
|
|
|
soinfo* lsi;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-04 01:49:39 +02:00
|
|
|
for (size_t idx = 0; idx < count; ++idx, ++rel) {
|
2009-03-04 04:28:35 +01:00
|
|
|
unsigned type = ELF32_R_TYPE(rel->r_info);
|
|
|
|
unsigned sym = ELF32_R_SYM(rel->r_info);
|
2012-06-18 23:38:46 +02:00
|
|
|
unsigned reloc = (unsigned)(rel->r_offset + si->load_bias);
|
2009-03-04 04:28:35 +01:00
|
|
|
unsigned sym_addr = 0;
|
2013-03-01 00:58:45 +01:00
|
|
|
char* sym_name = NULL;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("Processing '%s' relocation at index %d\n", si->name, idx);
|
2012-07-31 21:07:22 +02:00
|
|
|
if (type == 0) { // R_*_NONE
|
|
|
|
continue;
|
|
|
|
}
|
2013-03-01 00:58:45 +01:00
|
|
|
if (sym != 0) {
|
2009-05-12 19:59:09 +02:00
|
|
|
sym_name = (char *)(strtab + symtab[sym].st_name);
|
2012-08-30 12:48:32 +02:00
|
|
|
s = soinfo_do_lookup(si, sym_name, &lsi, needed);
|
2013-03-01 00:58:45 +01:00
|
|
|
if (s == NULL) {
|
2009-10-26 20:05:23 +01:00
|
|
|
/* We only allow an undefined symbol if this is a weak
|
|
|
|
reference.. */
|
|
|
|
s = &symtab[sym];
|
|
|
|
if (ELF32_ST_BIND(s->st_info) != STB_WEAK) {
|
2012-08-29 22:10:54 +02:00
|
|
|
DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, si->name);
|
2009-10-26 20:05:23 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* IHI0044C AAELF 4.5.1.1:
|
|
|
|
|
|
|
|
Libraries are not searched to resolve weak references.
|
|
|
|
It is not an error for a weak reference to remain
|
|
|
|
unsatisfied.
|
|
|
|
|
|
|
|
During linking, the value of an undefined weak reference is:
|
|
|
|
- Zero if the relocation type is absolute
|
|
|
|
- The address of the place if the relocation is pc-relative
|
2012-08-14 23:07:59 +02:00
|
|
|
- The address of nominal base address if the relocation
|
2009-10-26 20:05:23 +01:00
|
|
|
type is base-relative.
|
|
|
|
*/
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
#if defined(ANDROID_ARM_LINKER)
|
|
|
|
case R_ARM_JUMP_SLOT:
|
|
|
|
case R_ARM_GLOB_DAT:
|
|
|
|
case R_ARM_ABS32:
|
|
|
|
case R_ARM_RELATIVE: /* Don't care. */
|
|
|
|
#elif defined(ANDROID_X86_LINKER)
|
2012-07-31 21:07:22 +02:00
|
|
|
case R_386_JMP_SLOT:
|
2009-10-26 20:05:23 +01:00
|
|
|
case R_386_GLOB_DAT:
|
|
|
|
case R_386_32:
|
|
|
|
case R_386_RELATIVE: /* Dont' care. */
|
|
|
|
#endif /* ANDROID_*_LINKER */
|
|
|
|
/* sym_addr was initialized to be zero above or relocation
|
|
|
|
code below does not care about value of sym_addr.
|
|
|
|
No need to do anything. */
|
|
|
|
break;
|
|
|
|
|
|
|
|
#if defined(ANDROID_X86_LINKER)
|
|
|
|
case R_386_PC32:
|
|
|
|
sym_addr = reloc;
|
|
|
|
break;
|
|
|
|
#endif /* ANDROID_X86_LINKER */
|
|
|
|
|
|
|
|
#if defined(ANDROID_ARM_LINKER)
|
|
|
|
case R_ARM_COPY:
|
|
|
|
/* Fall through. Can't really copy if weak symbol is
|
|
|
|
not found in run-time. */
|
|
|
|
#endif /* ANDROID_ARM_LINKER */
|
|
|
|
default:
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("unknown weak reloc type %d @ %p (%d)",
|
|
|
|
type, rel, (int) (rel - start));
|
2009-10-26 20:05:23 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* We got a definition. */
|
2009-03-04 04:28:35 +01:00
|
|
|
#if 0
|
2013-03-01 00:58:45 +01:00
|
|
|
if ((base == 0) && (si->base != 0)) {
|
2012-07-31 21:07:22 +02:00
|
|
|
/* linking from libraries to main image is bad */
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("cannot locate \"%s\"...",
|
|
|
|
strtab + symtab[sym].st_name);
|
2012-07-31 21:07:22 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
#endif
|
2012-08-30 12:48:32 +02:00
|
|
|
sym_addr = (unsigned)(s->st_value + lsi->load_bias);
|
2012-07-31 21:07:22 +02:00
|
|
|
}
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocSymbol);
|
2009-03-04 04:28:35 +01:00
|
|
|
} else {
|
2009-10-26 20:05:23 +01:00
|
|
|
s = NULL;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: This is ugly. Split up the relocations by arch into
|
|
|
|
* different files.
|
|
|
|
*/
|
|
|
|
switch(type){
|
|
|
|
#if defined(ANDROID_ARM_LINKER)
|
|
|
|
case R_ARM_JUMP_SLOT:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocAbsolute);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO JMP_SLOT %08x <- %08x %s\n", reloc, sym_addr, sym_name);
|
2009-03-04 04:28:35 +01:00
|
|
|
*((unsigned*)reloc) = sym_addr;
|
|
|
|
break;
|
|
|
|
case R_ARM_GLOB_DAT:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocAbsolute);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO GLOB_DAT %08x <- %08x %s\n", reloc, sym_addr, sym_name);
|
2009-03-04 04:28:35 +01:00
|
|
|
*((unsigned*)reloc) = sym_addr;
|
|
|
|
break;
|
|
|
|
case R_ARM_ABS32:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocAbsolute);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO ABS %08x <- %08x %s\n", reloc, sym_addr, sym_name);
|
2009-03-04 04:28:35 +01:00
|
|
|
*((unsigned*)reloc) += sym_addr;
|
|
|
|
break;
|
2009-11-17 23:56:26 +01:00
|
|
|
case R_ARM_REL32:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocRelative);
|
2009-11-17 23:56:26 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x - %08x %s\n",
|
2009-11-17 23:56:26 +01:00
|
|
|
reloc, sym_addr, rel->r_offset, sym_name);
|
|
|
|
*((unsigned*)reloc) += sym_addr - rel->r_offset;
|
|
|
|
break;
|
2009-03-04 04:28:35 +01:00
|
|
|
#elif defined(ANDROID_X86_LINKER)
|
2012-07-31 21:07:22 +02:00
|
|
|
case R_386_JMP_SLOT:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocAbsolute);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO JMP_SLOT %08x <- %08x %s\n", reloc, sym_addr, sym_name);
|
2009-03-04 04:28:35 +01:00
|
|
|
*((unsigned*)reloc) = sym_addr;
|
|
|
|
break;
|
|
|
|
case R_386_GLOB_DAT:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocAbsolute);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO GLOB_DAT %08x <- %08x %s\n", reloc, sym_addr, sym_name);
|
2009-03-04 04:28:35 +01:00
|
|
|
*((unsigned*)reloc) = sym_addr;
|
|
|
|
break;
|
2012-07-31 21:07:22 +02:00
|
|
|
#elif defined(ANDROID_MIPS_LINKER)
|
|
|
|
case R_MIPS_REL32:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocAbsolute);
|
2012-07-31 21:07:22 +02:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x %s\n",
|
2012-07-31 21:07:22 +02:00
|
|
|
reloc, sym_addr, (sym_name) ? sym_name : "*SECTIONHDR*");
|
|
|
|
if (s) {
|
|
|
|
*((unsigned*)reloc) += sym_addr;
|
|
|
|
} else {
|
|
|
|
*((unsigned*)reloc) += si->base;
|
|
|
|
}
|
|
|
|
break;
|
2009-03-04 04:28:35 +01:00
|
|
|
#endif /* ANDROID_*_LINKER */
|
|
|
|
|
|
|
|
#if defined(ANDROID_ARM_LINKER)
|
|
|
|
case R_ARM_RELATIVE:
|
|
|
|
#elif defined(ANDROID_X86_LINKER)
|
|
|
|
case R_386_RELATIVE:
|
|
|
|
#endif /* ANDROID_*_LINKER */
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocRelative);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-08-04 01:49:39 +02:00
|
|
|
if (sym) {
|
2012-11-02 20:37:13 +01:00
|
|
|
DL_ERR("odd RELATIVE form...");
|
2009-03-04 04:28:35 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO RELATIVE %08x <- +%08x\n", reloc, si->base);
|
2009-03-04 04:28:35 +01:00
|
|
|
*((unsigned*)reloc) += si->base;
|
|
|
|
break;
|
|
|
|
|
|
|
|
#if defined(ANDROID_X86_LINKER)
|
|
|
|
case R_386_32:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocRelative);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO R_386_32 %08x <- +%08x %s\n", reloc, sym_addr, sym_name);
|
2009-03-04 04:28:35 +01:00
|
|
|
*((unsigned *)reloc) += (unsigned)sym_addr;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case R_386_PC32:
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocRelative);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO R_386_PC32 %08x <- +%08x (%08x - %08x) %s\n",
|
|
|
|
reloc, (sym_addr - reloc), sym_addr, reloc, sym_name);
|
2009-03-04 04:28:35 +01:00
|
|
|
*((unsigned *)reloc) += (unsigned)(sym_addr - reloc);
|
|
|
|
break;
|
|
|
|
#endif /* ANDROID_X86_LINKER */
|
|
|
|
|
|
|
|
#ifdef ANDROID_ARM_LINKER
|
|
|
|
case R_ARM_COPY:
|
2012-08-24 22:25:51 +02:00
|
|
|
if ((si->flags & FLAG_EXE) == 0) {
|
|
|
|
/*
|
|
|
|
* http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf
|
|
|
|
*
|
|
|
|
* Section 4.7.1.10 "Dynamic relocations"
|
|
|
|
* R_ARM_COPY may only appear in executable objects where e_type is
|
|
|
|
* set to ET_EXEC.
|
|
|
|
*
|
|
|
|
* TODO: FLAG_EXE is set for both ET_DYN and ET_EXEC executables.
|
|
|
|
* We should explicitly disallow ET_DYN executables from having
|
|
|
|
* R_ARM_COPY relocations.
|
|
|
|
*/
|
|
|
|
DL_ERR("%s R_ARM_COPY relocations only supported for ET_EXEC", si->name);
|
|
|
|
return -1;
|
|
|
|
}
|
2012-08-14 23:07:59 +02:00
|
|
|
count_relocation(kRelocCopy);
|
2009-03-04 04:28:35 +01:00
|
|
|
MARK(rel->r_offset);
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE_TYPE(RELO, "RELO %08x <- %d @ %08x %s\n", reloc, s->st_size, sym_addr, sym_name);
|
2012-08-24 22:25:51 +02:00
|
|
|
if (reloc == sym_addr) {
|
2012-08-30 12:48:32 +02:00
|
|
|
Elf32_Sym *src = soinfo_do_lookup(NULL, sym_name, &lsi, needed);
|
|
|
|
|
|
|
|
if (src == NULL) {
|
|
|
|
DL_ERR("%s R_ARM_COPY relocation source cannot be resolved", si->name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (lsi->has_DT_SYMBOLIC) {
|
|
|
|
DL_ERR("%s invalid R_ARM_COPY relocation against DT_SYMBOLIC shared "
|
|
|
|
"library %s (built with -Bsymbolic?)", si->name, lsi->name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (s->st_size < src->st_size) {
|
|
|
|
DL_ERR("%s R_ARM_COPY relocation size mismatch (%d < %d)",
|
|
|
|
si->name, s->st_size, src->st_size);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
memcpy((void*)reloc, (void*)(src->st_value + lsi->load_bias), src->st_size);
|
|
|
|
} else {
|
|
|
|
DL_ERR("%s R_ARM_COPY relocation target cannot be resolved", si->name);
|
2012-08-24 22:25:51 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
#endif /* ANDROID_ARM_LINKER */
|
|
|
|
|
|
|
|
default:
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("unknown reloc type %d @ %p (%d)",
|
|
|
|
type, rel, (int) (rel - start));
|
2009-03-04 04:28:35 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-31 21:07:22 +02:00
|
|
|
#ifdef ANDROID_MIPS_LINKER
|
2012-08-14 23:07:59 +02:00
|
|
|
static int mips_relocate_got(soinfo* si, soinfo* needed[]) {
|
2012-07-31 21:07:22 +02:00
|
|
|
unsigned *got;
|
|
|
|
unsigned local_gotno, gotsym, symtabno;
|
|
|
|
Elf32_Sym *symtab, *sym;
|
|
|
|
unsigned g;
|
|
|
|
|
|
|
|
got = si->plt_got;
|
|
|
|
local_gotno = si->mips_local_gotno;
|
|
|
|
gotsym = si->mips_gotsym;
|
|
|
|
symtabno = si->mips_symtabno;
|
|
|
|
symtab = si->symtab;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* got[0] is address of lazy resolver function
|
|
|
|
* got[1] may be used for a GNU extension
|
2012-08-14 23:07:59 +02:00
|
|
|
* set it to a recognizable address in case someone calls it
|
2012-07-31 21:07:22 +02:00
|
|
|
* (should be _rtld_bind_start)
|
|
|
|
* FIXME: maybe this should be in a separate routine
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((si->flags & FLAG_LINKER) == 0) {
|
|
|
|
g = 0;
|
|
|
|
got[g++] = 0xdeadbeef;
|
|
|
|
if (got[g] & 0x80000000) {
|
|
|
|
got[g++] = 0xdeadfeed;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Relocate the local GOT entries need to be relocated
|
|
|
|
*/
|
|
|
|
for (; g < local_gotno; g++) {
|
|
|
|
got[g] += si->load_bias;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now for the global GOT entries */
|
|
|
|
sym = symtab + gotsym;
|
|
|
|
got = si->plt_got + local_gotno;
|
|
|
|
for (g = gotsym; g < symtabno; g++, sym++, got++) {
|
2013-03-01 00:58:45 +01:00
|
|
|
const char* sym_name;
|
|
|
|
Elf32_Sym* s;
|
|
|
|
soinfo* lsi;
|
2012-07-31 21:07:22 +02:00
|
|
|
|
|
|
|
/* This is an undefined reference... try to locate it */
|
|
|
|
sym_name = si->strtab + sym->st_name;
|
2012-08-30 12:48:32 +02:00
|
|
|
s = soinfo_do_lookup(si, sym_name, &lsi, needed);
|
2012-07-31 21:07:22 +02:00
|
|
|
if (s == NULL) {
|
|
|
|
/* We only allow an undefined symbol if this is a weak
|
|
|
|
reference.. */
|
|
|
|
s = &symtab[g];
|
|
|
|
if (ELF32_ST_BIND(s->st_info) != STB_WEAK) {
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("cannot locate \"%s\"...", sym_name);
|
2012-07-31 21:07:22 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
*got = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* FIXME: is this sufficient?
|
|
|
|
* For reference see NetBSD link loader
|
|
|
|
* http://cvsweb.netbsd.org/bsdweb.cgi/src/libexec/ld.elf_so/arch/mips/mips_reloc.c?rev=1.53&content-type=text/x-cvsweb-markup
|
|
|
|
*/
|
2012-08-30 12:48:32 +02:00
|
|
|
*got = lsi->load_bias + s->st_value;
|
2012-07-31 21:07:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-05-18 14:37:41 +02:00
|
|
|
/* Please read the "Initialization and Termination functions" functions.
|
|
|
|
* of the linker design note in bionic/linker/README.TXT to understand
|
|
|
|
* what the following code is doing.
|
|
|
|
*
|
|
|
|
* The important things to remember are:
|
|
|
|
*
|
|
|
|
* DT_PREINIT_ARRAY must be called first for executables, and should
|
|
|
|
* not appear in shared libraries.
|
|
|
|
*
|
|
|
|
* DT_INIT should be called before DT_INIT_ARRAY if both are present
|
|
|
|
*
|
|
|
|
* DT_FINI should be called after DT_FINI_ARRAY if both are present
|
|
|
|
*
|
|
|
|
* DT_FINI_ARRAY must be parsed in reverse order.
|
|
|
|
*/
|
2012-11-01 23:16:56 +01:00
|
|
|
void soinfo::CallArray(const char* array_name UNUSED, unsigned* array, int count, bool reverse) {
|
|
|
|
if (array == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
2009-05-18 14:37:41 +02:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
int step = 1;
|
|
|
|
if (reverse) {
|
|
|
|
array += (count-1);
|
|
|
|
step = -1;
|
|
|
|
}
|
2009-05-18 14:37:41 +02:00
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Calling %s @ %p [%d] for '%s' ]\n", array_name, array, count, name);
|
2009-05-18 14:37:41 +02:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
for (int n = count; n > 0; n--) {
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Looking at %s[%d] *%p == 0x%08x ]\n", array_name, n, array, *array);
|
2012-11-01 23:16:56 +01:00
|
|
|
void (*func)() = (void (*)()) *array;
|
|
|
|
array += step;
|
2013-01-04 00:44:03 +01:00
|
|
|
CallFunction("function", func);
|
2012-11-01 23:16:56 +01:00
|
|
|
}
|
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Done calling %s for '%s' ]\n", array_name, name);
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
void soinfo::CallFunction(const char* function_name UNUSED, void (*function)()) {
|
2013-01-04 00:44:03 +01:00
|
|
|
if (function == NULL || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
|
2012-11-01 23:16:56 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Calling %s @ %p for '%s' ]\n", function_name, function, name);
|
2012-11-01 23:16:56 +01:00
|
|
|
function();
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Done calling %s for '%s' ]\n", function_name, name);
|
2013-01-04 00:44:03 +01:00
|
|
|
|
|
|
|
// The function may have called dlopen(3) or dlclose(3), so we need to ensure our data structures
|
|
|
|
// are still writable. This happens with our debug malloc (see http://b/7941716).
|
|
|
|
set_soinfo_pool_protection(PROT_READ | PROT_WRITE);
|
2012-08-13 15:58:37 +02:00
|
|
|
}
|
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
void soinfo::CallPreInitConstructors() {
|
|
|
|
CallArray("DT_PREINIT_ARRAY", preinit_array, preinit_array_count, false);
|
|
|
|
}
|
2011-12-21 10:03:54 +01:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
void soinfo::CallConstructors() {
|
|
|
|
if (constructors_called) {
|
|
|
|
return;
|
|
|
|
}
|
2011-12-21 10:03:54 +01:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
// We set constructors_called before actually calling the constructors, otherwise it doesn't
|
|
|
|
// protect against recursive constructor calls. One simple example of constructor recursion
|
|
|
|
// is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so:
|
|
|
|
// 1. The program depends on libc, so libc's constructor is called here.
|
|
|
|
// 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so.
|
|
|
|
// 3. dlopen() calls the constructors on the newly created
|
|
|
|
// soinfo for libc_malloc_debug_leak.so.
|
|
|
|
// 4. The debug .so depends on libc, so CallConstructors is
|
|
|
|
// called again with the libc soinfo. If it doesn't trigger the early-
|
|
|
|
// out above, the libc constructor will be called again (recursively!).
|
|
|
|
constructors_called = true;
|
|
|
|
|
|
|
|
if (!(flags & FLAG_EXE) && preinit_array) {
|
|
|
|
DL_ERR("shared library \"%s\" has a preinit_array table @ %p", name, preinit_array);
|
|
|
|
return;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
if (dynamic != NULL) {
|
|
|
|
for (Elf32_Dyn* d = dynamic; d->d_tag != DT_NULL; ++d) {
|
|
|
|
if (d->d_tag == DT_NEEDED) {
|
|
|
|
const char* library_name = strtab + d->d_un.d_val;
|
|
|
|
soinfo* lsi = find_loaded_library(library_name);
|
2012-11-01 23:16:56 +01:00
|
|
|
if (lsi == NULL) {
|
|
|
|
DL_ERR("\"%s\": could not initialize dependent library", name);
|
|
|
|
} else {
|
|
|
|
lsi->CallConstructors();
|
|
|
|
}
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
2012-11-01 23:16:56 +01:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
CallFunction("DT_INIT", init_func);
|
|
|
|
CallArray("DT_INIT_ARRAY", init_array, init_array_count, false);
|
2011-12-21 10:03:54 +01:00
|
|
|
}
|
2009-05-18 14:37:41 +02:00
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
void soinfo::CallDestructors() {
|
|
|
|
CallArray("DT_FINI_ARRAY", fini_array, fini_array_count, true);
|
|
|
|
CallFunction("DT_FINI", fini_func);
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Force any of the closed stdin, stdout and stderr to be associated with
|
|
|
|
/dev/null. */
|
2012-10-17 00:54:46 +02:00
|
|
|
static int nullify_closed_stdio() {
|
2009-03-04 04:28:35 +01:00
|
|
|
int dev_null, i, status;
|
|
|
|
int return_value = 0;
|
|
|
|
|
2012-06-12 16:25:37 +02:00
|
|
|
dev_null = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR));
|
2009-03-04 04:28:35 +01:00
|
|
|
if (dev_null < 0) {
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("cannot open /dev/null: %s", strerror(errno));
|
2009-03-04 04:28:35 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Opened /dev/null file-descriptor=%d]\n", dev_null);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
|
|
|
/* If any of the stdio file descriptors is valid and not associated
|
|
|
|
with /dev/null, dup /dev/null to it. */
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
/* If it is /dev/null already, we are done. */
|
2012-08-04 01:49:39 +02:00
|
|
|
if (i == dev_null) {
|
2009-03-04 04:28:35 +01:00
|
|
|
continue;
|
2012-08-04 01:49:39 +02:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Nullifying stdio file descriptor %d]\n", i);
|
2012-08-04 01:49:39 +02:00
|
|
|
status = TEMP_FAILURE_RETRY(fcntl(i, F_GETFL));
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-04 01:49:39 +02:00
|
|
|
/* If file is opened, we are good. */
|
|
|
|
if (status != -1) {
|
|
|
|
continue;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
|
|
|
/* The only error we allow is that the file descriptor does not
|
|
|
|
exist, in which case we dup /dev/null to it. */
|
|
|
|
if (errno != EBADF) {
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("fcntl failed: %s", strerror(errno));
|
2009-03-04 04:28:35 +01:00
|
|
|
return_value = -1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try dupping /dev/null to this stdio file descriptor and
|
|
|
|
repeat if there is a signal. Note that any errors in closing
|
|
|
|
the stdio descriptor are lost. */
|
2012-08-04 01:49:39 +02:00
|
|
|
status = TEMP_FAILURE_RETRY(dup2(dev_null, i));
|
2009-03-04 04:28:35 +01:00
|
|
|
if (status < 0) {
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("dup2 failed: %s", strerror(errno));
|
2009-03-04 04:28:35 +01:00
|
|
|
return_value = -1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If /dev/null is not one of the stdio file descriptors, close it. */
|
|
|
|
if (dev_null > 2) {
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Closing /dev/null file-descriptor=%d]\n", dev_null);
|
2012-08-04 01:49:39 +02:00
|
|
|
status = TEMP_FAILURE_RETRY(close(dev_null));
|
|
|
|
if (status == -1) {
|
|
|
|
DL_ERR("close failed: %s", strerror(errno));
|
2009-03-04 04:28:35 +01:00
|
|
|
return_value = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
static bool soinfo_link_image(soinfo* si) {
|
2012-05-31 13:20:36 +02:00
|
|
|
/* "base" might wrap around UINT32_MAX. */
|
2012-06-18 23:38:46 +02:00
|
|
|
Elf32_Addr base = si->load_bias;
|
2012-06-19 01:24:17 +02:00
|
|
|
const Elf32_Phdr *phdr = si->phdr;
|
2009-03-04 04:28:35 +01:00
|
|
|
int phnum = si->phnum;
|
2013-03-01 00:58:45 +01:00
|
|
|
bool relocating_linker = (si->flags & FLAG_LINKER) != 0;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-06-19 01:24:17 +02:00
|
|
|
/* We can't debug anything until the linker is relocated */
|
|
|
|
if (!relocating_linker) {
|
2012-11-02 20:37:13 +01:00
|
|
|
INFO("[ linking %s ]\n", si->name);
|
|
|
|
DEBUG("si->base = 0x%08x si->flags = 0x%08x\n", si->base, si->flags);
|
2012-06-19 01:24:17 +02:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-06-19 00:08:39 +02:00
|
|
|
/* Extract dynamic section */
|
2012-10-31 22:20:03 +01:00
|
|
|
size_t dynamic_count;
|
2013-01-12 00:32:20 +01:00
|
|
|
Elf32_Word dynamic_flags;
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
phdr_table_get_dynamic_section(phdr, phnum, base, &si->dynamic,
|
2013-01-12 00:32:20 +01:00
|
|
|
&dynamic_count, &dynamic_flags);
|
2012-06-19 00:08:39 +02:00
|
|
|
if (si->dynamic == NULL) {
|
2012-06-19 01:24:17 +02:00
|
|
|
if (!relocating_linker) {
|
2012-10-31 22:20:03 +01:00
|
|
|
DL_ERR("missing PT_DYNAMIC in \"%s\"", si->name);
|
2012-06-19 01:24:17 +02:00
|
|
|
}
|
2012-10-31 22:20:03 +01:00
|
|
|
return false;
|
2012-06-19 00:08:39 +02:00
|
|
|
} else {
|
2012-06-19 01:24:17 +02:00
|
|
|
if (!relocating_linker) {
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("dynamic = %p\n", si->dynamic);
|
2012-06-19 01:24:17 +02:00
|
|
|
}
|
2012-06-19 00:08:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef ANDROID_ARM_LINKER
|
|
|
|
(void) phdr_table_get_arm_exidx(phdr, phnum, base,
|
|
|
|
&si->ARM_exidx, &si->ARM_exidx_count);
|
|
|
|
#endif
|
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
/* extract useful information from dynamic section */
|
2013-03-01 00:58:45 +01:00
|
|
|
uint32_t needed_count = 0;
|
|
|
|
for (Elf32_Dyn* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
|
|
|
|
DEBUG("d = %p, d[0](tag) = 0x%08x d[1](val) = 0x%08x\n", d, d->d_tag, d->d_un.d_val);
|
|
|
|
switch(d->d_tag){
|
2009-03-04 04:28:35 +01:00
|
|
|
case DT_HASH:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->nbucket = ((unsigned *) (base + d->d_un.d_ptr))[0];
|
|
|
|
si->nchain = ((unsigned *) (base + d->d_un.d_ptr))[1];
|
|
|
|
si->bucket = (unsigned *) (base + d->d_un.d_ptr + 8);
|
|
|
|
si->chain = (unsigned *) (base + d->d_un.d_ptr + 8 + si->nbucket * 4);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_STRTAB:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->strtab = (const char *) (base + d->d_un.d_ptr);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_SYMTAB:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->symtab = (Elf32_Sym *) (base + d->d_un.d_ptr);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_PLTREL:
|
2013-03-01 00:58:45 +01:00
|
|
|
if (d->d_un.d_val != DT_REL) {
|
2012-10-31 22:20:03 +01:00
|
|
|
DL_ERR("unsupported DT_RELA in \"%s\"", si->name);
|
|
|
|
return false;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case DT_JMPREL:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->plt_rel = (Elf32_Rel*) (base + d->d_un.d_ptr);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_PLTRELSZ:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->plt_rel_count = d->d_un.d_val / sizeof(Elf32_Rel);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_REL:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->rel = (Elf32_Rel*) (base + d->d_un.d_ptr);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_RELSZ:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->rel_count = d->d_un.d_val / sizeof(Elf32_Rel);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_PLTGOT:
|
|
|
|
/* Save this in case we decide to do lazy binding. We don't yet. */
|
2013-03-01 00:58:45 +01:00
|
|
|
si->plt_got = (unsigned *)(base + d->d_un.d_ptr);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_DEBUG:
|
2012-08-14 23:07:59 +02:00
|
|
|
// Set the DT_DEBUG entry to the address of _r_debug for GDB
|
2013-01-12 00:32:20 +01:00
|
|
|
// if the dynamic table is writable
|
2013-01-14 18:56:21 +01:00
|
|
|
if ((dynamic_flags & PF_W) != 0) {
|
2013-03-01 00:58:45 +01:00
|
|
|
d->d_un.d_val = (int) &_r_debug;
|
2013-01-14 18:56:21 +01:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
2009-11-06 02:36:37 +01:00
|
|
|
case DT_RELA:
|
2012-10-31 22:20:03 +01:00
|
|
|
DL_ERR("unsupported DT_RELA in \"%s\"", si->name);
|
|
|
|
return false;
|
2009-03-04 04:28:35 +01:00
|
|
|
case DT_INIT:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->init_func = (void (*)(void))(base + d->d_un.d_ptr);
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("%s constructors (init func) found at %p\n", si->name, si->init_func);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_FINI:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->fini_func = (void (*)(void))(base + d->d_un.d_ptr);
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("%s destructors (fini func) found at %p\n", si->name, si->fini_func);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_INIT_ARRAY:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->init_array = (unsigned *)(base + d->d_un.d_ptr);
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("%s constructors (init_array) found at %p\n", si->name, si->init_array);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_INIT_ARRAYSZ:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->init_array_count = ((unsigned)d->d_un.d_val) / sizeof(Elf32_Addr);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_FINI_ARRAY:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->fini_array = (unsigned *)(base + d->d_un.d_ptr);
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("%s destructors (fini_array) found at %p\n", si->name, si->fini_array);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_FINI_ARRAYSZ:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->fini_array_count = ((unsigned)d->d_un.d_val) / sizeof(Elf32_Addr);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_PREINIT_ARRAY:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->preinit_array = (unsigned *)(base + d->d_un.d_ptr);
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("%s constructors (preinit_array) found at %p\n", si->name, si->preinit_array);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_PREINIT_ARRAYSZ:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->preinit_array_count = ((unsigned)d->d_un.d_val) / sizeof(Elf32_Addr);
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
|
|
|
case DT_TEXTREL:
|
2012-08-11 06:08:42 +02:00
|
|
|
si->has_text_relocations = true;
|
2009-03-04 04:28:35 +01:00
|
|
|
break;
|
2012-08-30 12:48:32 +02:00
|
|
|
case DT_SYMBOLIC:
|
|
|
|
si->has_DT_SYMBOLIC = true;
|
|
|
|
break;
|
2013-03-01 00:58:45 +01:00
|
|
|
case DT_NEEDED:
|
|
|
|
++needed_count;
|
|
|
|
break;
|
|
|
|
#if defined DT_FLAGS
|
|
|
|
// TODO: why is DT_FLAGS not defined?
|
2012-08-30 12:48:32 +02:00
|
|
|
case DT_FLAGS:
|
2013-03-01 00:58:45 +01:00
|
|
|
if (d->d_un.d_val & DF_TEXTREL) {
|
2012-08-30 12:48:32 +02:00
|
|
|
si->has_text_relocations = true;
|
|
|
|
}
|
2013-03-01 00:58:45 +01:00
|
|
|
if (d->d_un.d_val & DF_SYMBOLIC) {
|
2012-08-30 12:48:32 +02:00
|
|
|
si->has_DT_SYMBOLIC = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
2012-07-31 21:07:22 +02:00
|
|
|
#if defined(ANDROID_MIPS_LINKER)
|
|
|
|
case DT_STRSZ:
|
|
|
|
case DT_SYMENT:
|
|
|
|
case DT_RELENT:
|
|
|
|
break;
|
|
|
|
case DT_MIPS_RLD_MAP:
|
2012-08-14 23:07:59 +02:00
|
|
|
// Set the DT_MIPS_RLD_MAP entry to the address of _r_debug for GDB.
|
2012-07-31 21:07:22 +02:00
|
|
|
{
|
2013-03-01 00:58:45 +01:00
|
|
|
r_debug** dp = (r_debug**) d->d_un.d_ptr;
|
2012-07-31 21:07:22 +02:00
|
|
|
*dp = &_r_debug;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case DT_MIPS_RLD_VERSION:
|
|
|
|
case DT_MIPS_FLAGS:
|
|
|
|
case DT_MIPS_BASE_ADDRESS:
|
|
|
|
case DT_MIPS_UNREFEXTNO:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DT_MIPS_SYMTABNO:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->mips_symtabno = d->d_un.d_val;
|
2012-07-31 21:07:22 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DT_MIPS_LOCAL_GOTNO:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->mips_local_gotno = d->d_un.d_val;
|
2012-07-31 21:07:22 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DT_MIPS_GOTSYM:
|
2013-03-01 00:58:45 +01:00
|
|
|
si->mips_gotsym = d->d_un.d_val;
|
2012-07-31 21:07:22 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("Unused DT entry: type 0x%08x arg 0x%08x\n", d[-1], d[0]);
|
2012-07-31 21:07:22 +02:00
|
|
|
break;
|
|
|
|
#endif
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("si->base = 0x%08x, si->strtab = %p, si->symtab = %p\n",
|
|
|
|
si->base, si->strtab, si->symtab);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
// Sanity checks.
|
2013-03-01 00:58:45 +01:00
|
|
|
if (relocating_linker && needed_count != 0) {
|
|
|
|
DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
|
|
|
|
return false;
|
|
|
|
}
|
2012-10-31 22:20:03 +01:00
|
|
|
if (si->nbucket == 0) {
|
|
|
|
DL_ERR("empty/missing DT_HASH in \"%s\" (built with --hash-style=gnu?)", si->name);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (si->strtab == 0) {
|
|
|
|
DL_ERR("empty/missing DT_STRTAB in \"%s\"", si->name);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (si->symtab == 0) {
|
|
|
|
DL_ERR("empty/missing DT_SYMTAB in \"%s\"", si->name);
|
|
|
|
return false;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2009-12-31 19:09:10 +01:00
|
|
|
/* if this is the main executable, then load all of the preloads now */
|
2012-11-01 23:16:56 +01:00
|
|
|
if (si->flags & FLAG_EXE) {
|
2013-03-01 00:58:45 +01:00
|
|
|
memset(gLdPreloads, 0, sizeof(gLdPreloads));
|
2012-11-01 23:16:56 +01:00
|
|
|
for (size_t i = 0; gLdPreloadNames[i] != NULL; i++) {
|
|
|
|
soinfo* lsi = find_library(gLdPreloadNames[i]);
|
|
|
|
if (lsi == NULL) {
|
2013-03-06 03:47:58 +01:00
|
|
|
strlcpy(tmp_err_buf, linker_get_error_buffer(), sizeof(tmp_err_buf));
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("could not load library \"%s\" needed by \"%s\"; caused by %s",
|
2012-10-31 22:20:03 +01:00
|
|
|
gLdPreloadNames[i], si->name, tmp_err_buf);
|
|
|
|
return false;
|
2009-12-31 19:09:10 +01:00
|
|
|
}
|
2013-03-01 00:58:45 +01:00
|
|
|
gLdPreloads[i] = lsi;
|
2009-12-31 19:09:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
soinfo** needed = (soinfo**) alloca((1 + needed_count) * sizeof(soinfo*));
|
|
|
|
soinfo** pneeded = needed;
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
for (Elf32_Dyn* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
|
|
|
|
if (d->d_tag == DT_NEEDED) {
|
|
|
|
const char* library_name = si->strtab + d->d_un.d_val;
|
|
|
|
DEBUG("%s needs %s\n", si->name, library_name);
|
|
|
|
soinfo* lsi = find_library(library_name);
|
2012-11-01 23:16:56 +01:00
|
|
|
if (lsi == NULL) {
|
2013-03-06 03:47:58 +01:00
|
|
|
strlcpy(tmp_err_buf, linker_get_error_buffer(), sizeof(tmp_err_buf));
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("could not load library \"%s\" needed by \"%s\"; caused by %s",
|
2013-03-01 00:58:45 +01:00
|
|
|
library_name, si->name, tmp_err_buf);
|
2012-10-31 22:20:03 +01:00
|
|
|
return false;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
*pneeded++ = lsi;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
}
|
linker: avoid clobbering the .dynamic section of shared libs
This patch removes the DT_NEEDED hack which stores pointers
to soinfo structs in the .dynamic section of the library
being loaded.
Instead, it caches the soinfo struct pointers on the stack
during relocation time. After relocation time, i.e. when
calling constructors and destructors of the shared library
and its dependencies, uncached access is used instead,
doing lookups using the string table entries pointed to by
the DT_NEEDED entries.
By removing this hack, it is no longer needed to undo the
PT_GNURELRO protection, i.e., all non-writable mappings
can remain non-writable during their entire lifespan.
Even though, strictly speaking, the algorithmic complexity
has increased somewhat, the real-world adverse effect
is negligible on the systems I have tested.
Change-Id: I2361502560b96b5878f7f94a8e8a215350d70d64
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@gmail.com>
2012-08-14 12:30:09 +02:00
|
|
|
*pneeded = NULL;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-11 06:08:42 +02:00
|
|
|
if (si->has_text_relocations) {
|
|
|
|
/* Unprotect the segments, i.e. make them writable, to allow
|
|
|
|
* text relocations to work properly. We will later call
|
|
|
|
* phdr_table_protect_segments() after all of them are applied
|
|
|
|
* and all constructors are run.
|
|
|
|
*/
|
|
|
|
if (phdr_table_unprotect_segments(si->phdr, si->phnum, si->load_bias) < 0) {
|
|
|
|
DL_ERR("can't unprotect loadable segments for \"%s\": %s",
|
|
|
|
si->name, strerror(errno));
|
2012-10-31 22:20:03 +01:00
|
|
|
return false;
|
2012-08-11 06:08:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
if (si->plt_rel != NULL) {
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("[ relocating %s plt ]\n", si->name );
|
2013-03-01 00:58:45 +01:00
|
|
|
if (soinfo_relocate(si, si->plt_rel, si->plt_rel_count, needed)) {
|
2012-10-31 22:20:03 +01:00
|
|
|
return false;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
2013-03-01 00:58:45 +01:00
|
|
|
if (si->rel != NULL) {
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("[ relocating %s ]\n", si->name );
|
2013-03-01 00:58:45 +01:00
|
|
|
if (soinfo_relocate(si, si->rel, si->rel_count, needed)) {
|
2012-10-31 22:20:03 +01:00
|
|
|
return false;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-07-31 21:07:22 +02:00
|
|
|
#ifdef ANDROID_MIPS_LINKER
|
2012-10-31 22:20:03 +01:00
|
|
|
if (mips_relocate_got(si, needed)) {
|
|
|
|
return false;
|
2012-07-31 21:07:22 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
si->flags |= FLAG_LINKED;
|
2012-11-02 20:37:13 +01:00
|
|
|
DEBUG("[ finished linking %s ]\n", si->name);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-11 06:08:42 +02:00
|
|
|
if (si->has_text_relocations) {
|
|
|
|
/* All relocations are done, we can protect our segments back to
|
|
|
|
* read-only. */
|
|
|
|
if (phdr_table_protect_segments(si->phdr, si->phnum, si->load_bias) < 0) {
|
|
|
|
DL_ERR("can't protect segments for \"%s\": %s",
|
|
|
|
si->name, strerror(errno));
|
2012-10-31 22:20:03 +01:00
|
|
|
return false;
|
2012-08-11 06:08:42 +02:00
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-06-19 01:24:17 +02:00
|
|
|
/* We can also turn on GNU RELRO protection */
|
|
|
|
if (phdr_table_protect_gnu_relro(si->phdr, si->phnum, si->load_bias) < 0) {
|
2012-08-04 01:49:39 +02:00
|
|
|
DL_ERR("can't enable GNU RELRO protection for \"%s\": %s",
|
|
|
|
si->name, strerror(errno));
|
2012-10-31 22:20:03 +01:00
|
|
|
return false;
|
2012-02-28 19:40:00 +01:00
|
|
|
}
|
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
// If this is a setuid/setgid program, close the security hole described in
|
|
|
|
// ftp://ftp.freebsd.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-02:23.stdio.asc
|
2012-10-30 01:37:13 +01:00
|
|
|
if (get_AT_SECURE()) {
|
2012-08-04 01:49:39 +02:00
|
|
|
nullify_closed_stdio();
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
notify_gdb_of_load(si);
|
2012-10-31 22:20:03 +01:00
|
|
|
return true;
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2011-11-12 00:53:17 +01:00
|
|
|
/*
|
|
|
|
* This code is called after the linker has linked itself and
|
|
|
|
* fixed it's own GOT. It is safe to make references to externs
|
|
|
|
* and other non-local data at this point.
|
|
|
|
*/
|
2013-02-07 19:14:39 +01:00
|
|
|
static unsigned __linker_init_post_relocation(KernelArgumentBlock& args, unsigned linker_base) {
|
|
|
|
/* NOTE: we store the args pointer on a special location
|
2009-07-17 17:55:01 +02:00
|
|
|
* of the temporary TLS area in order to pass it to
|
|
|
|
* the C Library's runtime initializer.
|
|
|
|
*
|
|
|
|
* The initializer must clear the slot and reset the TLS
|
|
|
|
* to point to a different location to ensure that no other
|
|
|
|
* shared library constructor can access it.
|
|
|
|
*/
|
2013-02-08 03:39:34 +01:00
|
|
|
__libc_init_tls(args);
|
2012-03-22 15:01:53 +01:00
|
|
|
|
|
|
|
#if TIMING
|
|
|
|
struct timeval t0, t1;
|
|
|
|
gettimeofday(&t0, 0);
|
|
|
|
#endif
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-10-30 01:37:13 +01:00
|
|
|
// Initialize environment functions, and get to the ELF aux vectors table.
|
2013-02-07 19:14:39 +01:00
|
|
|
linker_env_init(args);
|
2010-12-16 19:52:02 +01:00
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
debuggerd_init();
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-10-30 01:37:13 +01:00
|
|
|
// Get a few environment variables.
|
2012-11-02 20:37:13 +01:00
|
|
|
const char* LD_DEBUG = linker_env_get("LD_DEBUG");
|
|
|
|
if (LD_DEBUG != NULL) {
|
2013-03-06 03:47:58 +01:00
|
|
|
gLdDebugVerbosity = atoi(LD_DEBUG);
|
2012-10-30 01:37:13 +01:00
|
|
|
}
|
2010-12-16 19:52:02 +01:00
|
|
|
|
2012-10-30 01:37:13 +01:00
|
|
|
// Normally, these are cleaned by linker_env_init, but the test
|
|
|
|
// doesn't cost us anything.
|
|
|
|
const char* ldpath_env = NULL;
|
|
|
|
const char* ldpreload_env = NULL;
|
|
|
|
if (!get_AT_SECURE()) {
|
|
|
|
ldpath_env = linker_env_get("LD_LIBRARY_PATH");
|
|
|
|
ldpreload_env = linker_env_get("LD_PRELOAD");
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
INFO("[ android linker & debugger ]\n");
|
|
|
|
|
2013-02-07 19:14:39 +01:00
|
|
|
soinfo* si = soinfo_alloc(args.argv[0]);
|
2012-10-30 01:37:13 +01:00
|
|
|
if (si == NULL) {
|
|
|
|
exit(EXIT_FAILURE);
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-08-24 22:25:51 +02:00
|
|
|
/* bootstrap the link map, the main exe always needs to be first */
|
2009-03-04 04:28:35 +01:00
|
|
|
si->flags |= FLAG_EXE;
|
2012-08-14 23:07:59 +02:00
|
|
|
link_map* map = &(si->linkmap);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
|
|
|
map->l_addr = 0;
|
2013-02-07 19:14:39 +01:00
|
|
|
map->l_name = args.argv[0];
|
2009-03-04 04:28:35 +01:00
|
|
|
map->l_prev = NULL;
|
|
|
|
map->l_next = NULL;
|
|
|
|
|
|
|
|
_r_debug.r_map = map;
|
|
|
|
r_debug_tail = map;
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
/* gdb expects the linker to be in the debug shared object list.
|
|
|
|
* Without this, gdb has trouble locating the linker's ".text"
|
|
|
|
* and ".plt" sections. Gdb could also potentially use this to
|
|
|
|
* relocate the offset of our exported 'rtld_db_dlactivity' symbol.
|
|
|
|
* Don't use soinfo_alloc(), because the linker shouldn't
|
|
|
|
* be on the soinfo list.
|
2012-08-11 01:07:02 +02:00
|
|
|
*/
|
2013-03-01 00:58:45 +01:00
|
|
|
{
|
|
|
|
static soinfo linker_soinfo;
|
|
|
|
strlcpy(linker_soinfo.name, "/system/bin/linker", sizeof(linker_soinfo.name));
|
|
|
|
linker_soinfo.flags = 0;
|
|
|
|
linker_soinfo.base = linker_base;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the dynamic field in the link map otherwise gdb will complain with
|
|
|
|
* the following:
|
|
|
|
* warning: .dynamic section for "/system/bin/linker" is not at the
|
|
|
|
* expected address (wrong library or version mismatch?)
|
|
|
|
*/
|
|
|
|
Elf32_Ehdr *elf_hdr = (Elf32_Ehdr *) linker_base;
|
|
|
|
Elf32_Phdr *phdr = (Elf32_Phdr*)((unsigned char*) linker_base + elf_hdr->e_phoff);
|
|
|
|
phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base,
|
|
|
|
&linker_soinfo.dynamic, NULL, NULL);
|
|
|
|
insert_soinfo_into_debug_map(&linker_soinfo);
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2013-02-07 19:14:39 +01:00
|
|
|
// Extract information passed from the kernel.
|
|
|
|
si->phdr = reinterpret_cast<Elf32_Phdr*>(args.getauxval(AT_PHDR));
|
|
|
|
si->phnum = args.getauxval(AT_PHNUM);
|
|
|
|
si->entry = args.getauxval(AT_ENTRY);
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2011-11-15 17:17:28 +01:00
|
|
|
/* Compute the value of si->base. We can't rely on the fact that
|
|
|
|
* the first entry is the PHDR because this will not be true
|
|
|
|
* for certain executables (e.g. some in the NDK unit test suite)
|
|
|
|
*/
|
|
|
|
si->base = 0;
|
2012-06-19 01:24:17 +02:00
|
|
|
si->size = phdr_table_get_load_size(si->phdr, si->phnum);
|
2012-06-18 23:38:46 +02:00
|
|
|
si->load_bias = 0;
|
2013-02-07 19:14:39 +01:00
|
|
|
for (int i = 0; i < si->phnum; ++i) {
|
|
|
|
if (si->phdr[i].p_type == PT_PHDR) {
|
|
|
|
si->load_bias = reinterpret_cast<Elf32_Addr>(si->phdr) - si->phdr[i].p_vaddr;
|
|
|
|
si->base = reinterpret_cast<Elf32_Addr>(si->phdr) - si->phdr[i].p_offset;
|
|
|
|
break;
|
|
|
|
}
|
2011-11-15 17:17:28 +01:00
|
|
|
}
|
2013-03-01 00:58:45 +01:00
|
|
|
si->dynamic = NULL;
|
2010-07-22 01:18:21 +02:00
|
|
|
si->refcount = 1;
|
2009-03-04 04:28:35 +01:00
|
|
|
|
2012-08-04 01:49:39 +02:00
|
|
|
// Use LD_LIBRARY_PATH and LD_PRELOAD (but only if we aren't setuid/setgid).
|
|
|
|
parse_LD_LIBRARY_PATH(ldpath_env);
|
|
|
|
parse_LD_PRELOAD(ldpreload_env);
|
2009-12-31 19:09:10 +01:00
|
|
|
|
2012-08-30 12:48:32 +02:00
|
|
|
somain = si;
|
|
|
|
|
2012-10-31 22:20:03 +01:00
|
|
|
if (!soinfo_link_image(si)) {
|
2013-03-06 03:47:58 +01:00
|
|
|
__libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer());
|
2012-10-30 01:37:13 +01:00
|
|
|
exit(EXIT_FAILURE);
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
|
2012-11-01 23:16:56 +01:00
|
|
|
si->CallPreInitConstructors();
|
2012-08-13 15:58:37 +02:00
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
for (size_t i = 0; gLdPreloads[i] != NULL; ++i) {
|
|
|
|
gLdPreloads[i]->CallConstructors();
|
2012-07-14 18:49:27 +02:00
|
|
|
}
|
|
|
|
|
2013-03-01 00:58:45 +01:00
|
|
|
/* After the link_image, the si->load_bias is initialized.
|
|
|
|
* For so lib, the map->l_addr will be updated in notify_gdb_of_load.
|
|
|
|
* We need to update this value for so exe here. So Unwind_Backtrace
|
|
|
|
* for some arch like x86 could work correctly within so exe.
|
2012-09-13 12:07:24 +02:00
|
|
|
*/
|
2012-11-15 11:00:17 +01:00
|
|
|
map->l_addr = si->load_bias;
|
2012-11-01 23:16:56 +01:00
|
|
|
si->CallConstructors();
|
2011-12-21 10:03:54 +01:00
|
|
|
|
2009-03-04 04:28:35 +01:00
|
|
|
#if TIMING
|
|
|
|
gettimeofday(&t1,NULL);
|
2013-02-07 19:14:39 +01:00
|
|
|
PRINT("LINKER TIME: %s: %d microseconds\n", e.argv[0], (int) (
|
2009-03-04 04:28:35 +01:00
|
|
|
(((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) -
|
|
|
|
(((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec)
|
|
|
|
));
|
|
|
|
#endif
|
|
|
|
#if STATS
|
2013-02-07 19:14:39 +01:00
|
|
|
PRINT("RELO STATS: %s: %d abs, %d rel, %d copy, %d symbol\n", e.argv[0],
|
2012-08-14 23:07:59 +02:00
|
|
|
linker_stats.count[kRelocAbsolute],
|
|
|
|
linker_stats.count[kRelocRelative],
|
|
|
|
linker_stats.count[kRelocCopy],
|
|
|
|
linker_stats.count[kRelocSymbol]);
|
2009-03-04 04:28:35 +01:00
|
|
|
#endif
|
|
|
|
#if COUNT_PAGES
|
|
|
|
{
|
|
|
|
unsigned n;
|
|
|
|
unsigned i;
|
|
|
|
unsigned count = 0;
|
2013-03-01 00:58:45 +01:00
|
|
|
for (n = 0; n < 4096; n++) {
|
|
|
|
if (bitmask[n]) {
|
2009-03-04 04:28:35 +01:00
|
|
|
unsigned x = bitmask[n];
|
2013-03-01 00:58:45 +01:00
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
if (x & 1) {
|
|
|
|
count++;
|
|
|
|
}
|
2009-03-04 04:28:35 +01:00
|
|
|
x >>= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-02-07 19:14:39 +01:00
|
|
|
PRINT("PAGES MODIFIED: %s: %d (%dKB)\n", e.argv[0], count, count * 4);
|
2009-03-04 04:28:35 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if TIMING || STATS || COUNT_PAGES
|
|
|
|
fflush(stdout);
|
|
|
|
#endif
|
|
|
|
|
2012-11-02 20:37:13 +01:00
|
|
|
TRACE("[ Ready to execute '%s' @ 0x%08x ]\n", si->name, si->entry);
|
2009-03-04 04:28:35 +01:00
|
|
|
return si->entry;
|
|
|
|
}
|
2011-11-12 00:53:17 +01:00
|
|
|
|
2012-06-18 23:38:46 +02:00
|
|
|
/* Compute the load-bias of an existing executable. This shall only
|
|
|
|
* be used to compute the load bias of an executable or shared library
|
|
|
|
* that was loaded by the kernel itself.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* elf -> address of ELF header, assumed to be at the start of the file.
|
|
|
|
* Return:
|
|
|
|
* load bias, i.e. add the value of any p_vaddr in the file to get
|
|
|
|
* the corresponding address in memory.
|
|
|
|
*/
|
|
|
|
static Elf32_Addr
|
|
|
|
get_elf_exec_load_bias(const Elf32_Ehdr* elf)
|
|
|
|
{
|
|
|
|
Elf32_Addr offset = elf->e_phoff;
|
|
|
|
const Elf32_Phdr* phdr_table = (const Elf32_Phdr*)((char*)elf + offset);
|
|
|
|
const Elf32_Phdr* phdr_end = phdr_table + elf->e_phnum;
|
|
|
|
const Elf32_Phdr* phdr;
|
|
|
|
|
|
|
|
for (phdr = phdr_table; phdr < phdr_end; phdr++) {
|
|
|
|
if (phdr->p_type == PT_LOAD) {
|
|
|
|
return (Elf32_Addr)elf + phdr->p_offset - phdr->p_vaddr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-12 00:53:17 +01:00
|
|
|
/*
|
|
|
|
* This is the entry point for the linker, called from begin.S. This
|
|
|
|
* method is responsible for fixing the linker's own relocations, and
|
|
|
|
* then calling __linker_init_post_relocation().
|
|
|
|
*
|
|
|
|
* Because this method is called before the linker has fixed it's own
|
|
|
|
* relocations, any attempt to reference an extern variable, extern
|
|
|
|
* function, or other GOT reference will generate a segfault.
|
|
|
|
*/
|
2013-02-07 19:14:39 +01:00
|
|
|
extern "C" unsigned __linker_init(void* raw_args) {
|
|
|
|
KernelArgumentBlock args(raw_args);
|
|
|
|
|
|
|
|
unsigned linker_addr = args.getauxval(AT_BASE);
|
|
|
|
|
|
|
|
Elf32_Ehdr *elf_hdr = (Elf32_Ehdr*) linker_addr;
|
|
|
|
Elf32_Phdr *phdr = (Elf32_Phdr*)((unsigned char*) linker_addr + elf_hdr->e_phoff);
|
|
|
|
|
|
|
|
soinfo linker_so;
|
|
|
|
memset(&linker_so, 0, sizeof(soinfo));
|
|
|
|
|
|
|
|
linker_so.base = linker_addr;
|
|
|
|
linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum);
|
|
|
|
linker_so.load_bias = get_elf_exec_load_bias(elf_hdr);
|
2013-03-01 00:58:45 +01:00
|
|
|
linker_so.dynamic = NULL;
|
2013-02-07 19:14:39 +01:00
|
|
|
linker_so.phdr = phdr;
|
|
|
|
linker_so.phnum = elf_hdr->e_phnum;
|
|
|
|
linker_so.flags |= FLAG_LINKER;
|
|
|
|
|
|
|
|
if (!soinfo_link_image(&linker_so)) {
|
|
|
|
// It would be nice to print an error message, but if the linker
|
|
|
|
// can't link itself, there's no guarantee that we'll be able to
|
|
|
|
// call write() (because it involves a GOT reference).
|
|
|
|
//
|
|
|
|
// This situation should never occur unless the linker itself
|
|
|
|
// is corrupt.
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
2011-11-12 00:53:17 +01:00
|
|
|
|
2013-02-07 19:14:39 +01:00
|
|
|
// We have successfully fixed our own relocations. It's safe to run
|
|
|
|
// the main part of the linker now.
|
|
|
|
unsigned start_address = __linker_init_post_relocation(args, linker_addr);
|
2012-10-17 00:54:46 +02:00
|
|
|
|
2013-02-07 19:14:39 +01:00
|
|
|
set_soinfo_pool_protection(PROT_READ);
|
2012-11-01 23:16:56 +01:00
|
|
|
|
2013-02-07 19:14:39 +01:00
|
|
|
// Return the address that the calling assembly stub should jump to.
|
|
|
|
return start_address;
|
2011-11-12 00:53:17 +01:00
|
|
|
}
|