generic-library/bionic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Support loading libraries to a reserved address.

Browse Source 
Add flags and parameters to android_dlopen_ext() to allow loading a
library at an already-reserved fixed address. If the library to be
loaded will not fit within the space reserved, then the linker will
either fail, or allocate its own address space as usual, according to
which flag has been specified. This behaviour only applies to the
specific library requested; any other libraries loaded as dependencies
will be loaded in the normal fashion.

There is a new gtest included to cover the functionality added.

Bug: 13005501
Change-Id: I5d1810375b20fc51ba6a9b3191a25f9792c687f1
This commit is contained in:
Torne (Richard Coles) 2014-02-06 14:34:21 +00:00
parent 012cb4583a
commit 12bbb91645
7 changed files with 249 additions and 20 deletions

17
libc/include/android/dlext.h

@ -24,12 +24,27 @@ __BEGIN_DECLS
/* bitfield definitions for android_dlextinfo.flags */
enum {
/* When set, the reserved_addr and reserved_size fields must point to an
* already-reserved region of address space which will be used to load the
* library if it fits. If the reserved region is not large enough, the load
* will fail.
*/
ANDROID_DLEXT_RESERVED_ADDRESS = 0x1,
/* As DLEXT_RESERVED_ADDRESS, but if the reserved region is not large enough,
* the linker will choose an available address instead.
*/
ANDROID_DLEXT_RESERVED_ADDRESS_HINT = 0x2,
/* Mask of valid bits */
ANDROID_DLEXT_VALID_FLAG_BITS = 0,
ANDROID_DLEXT_VALID_FLAG_BITS = ANDROID_DLEXT_RESERVED_ADDRESS |
ANDROID_DLEXT_RESERVED_ADDRESS_HINT,
};
typedef struct {
int flags;
void* reserved_addr;
size_t reserved_size;
} android_dlextinfo;
extern void* android_dlopen_ext(const char* filename, int flag, const android_dlextinfo* extinfo);

18
linker/linker.cpp

@ -690,7 +690,7 @@ static int open_library(const char* name) {
return fd;
}
static soinfo* load_library(const char* name) {
static soinfo* load_library(const char* name, const android_dlextinfo* extinfo) {
// Open the file.
int fd = open_library(name);
if (fd == -1) {
@ -700,7 +700,7 @@ static soinfo* load_library(const char* name) {
// Read the ELF header and load the segments.
ElfReader elf_reader(name, fd);
if (!elf_reader.Load()) {
if (!elf_reader.Load(extinfo)) {
return NULL;
}
@ -735,7 +735,7 @@ static soinfo *find_loaded_library(const char* name) {
return NULL;
}
static soinfo* find_library_internal(const char* name) {
static soinfo* find_library_internal(const char* name, const android_dlextinfo* extinfo) {
if (name == NULL) {
return somain;
}
@ -750,7 +750,7 @@ static soinfo* find_library_internal(const char* name) {
}
TRACE("[ '%s' has not been loaded yet. Locating...]", name);
si = load_library(name);
si = load_library(name, extinfo);
if (si == NULL) {
return NULL;
}
@ -769,8 +769,8 @@ static soinfo* find_library_internal(const char* name) {
return si;
}
static soinfo* find_library(const char* name) {
soinfo* si = find_library_internal(name);
static soinfo* find_library(const char* name, const android_dlextinfo* extinfo) {
soinfo* si = find_library_internal(name, extinfo);
if (si != NULL) {
si->ref_count++;
}
@ -821,7 +821,7 @@ soinfo* do_dlopen(const char* name, int flags, const android_dlextinfo* extinfo)
return NULL;
}
set_soinfo_pool_protection(PROT_READ | PROT_WRITE);
soinfo* si = find_library(name);
soinfo* si = find_library(name, extinfo);
if (si != NULL) {
si->CallConstructors();
}
@ -1803,7 +1803,7 @@ static bool soinfo_link_image(soinfo* si) {
memset(gLdPreloads, 0, sizeof(gLdPreloads));
size_t preload_count = 0;
for (size_t i = 0; gLdPreloadNames[i] != NULL; i++) {
soinfo* lsi = find_library(gLdPreloadNames[i]);
soinfo* lsi = find_library(gLdPreloadNames[i], NULL);
if (lsi != NULL) {
gLdPreloads[preload_count++] = lsi;
} else {
@ -1821,7 +1821,7 @@ static bool soinfo_link_image(soinfo* si) {
if (d->d_tag == DT_NEEDED) {
const char* library_name = si->strtab + d->d_un.d_val;
DEBUG("%s needs %s", si->name, library_name);
soinfo* lsi = find_library(library_name);
soinfo* lsi = find_library(library_name, NULL);
if (lsi == NULL) {
strlcpy(tmp_err_buf, linker_get_error_buffer(), sizeof(tmp_err_buf));
DL_ERR("could not load library \"%s\" needed by \"%s\"; caused by %s",

38
linker/linker_phdr.cpp

@ -132,11 +132,11 @@ ElfReader::~ElfReader() {
}
}
bool ElfReader::Load() {
bool ElfReader::Load(const android_dlextinfo* extinfo) {
return ReadElfHeader() &&
VerifyElfHeader() &&
ReadProgramHeader() &&
ReserveAddressSpace() &&
ReserveAddressSpace(extinfo) &&
LoadSegments() &&
FindPhdr();
}
@ -291,7 +291,7 @@ size_t phdr_table_get_load_size(const ElfW(Phdr)* phdr_table, size_t phdr_count,
// Reserve a virtual address range big enough to hold all loadable
// segments of a program header table. This is done by creating a
// private anonymous mmap() with PROT_NONE.
bool ElfReader::ReserveAddressSpace() {
bool ElfReader::ReserveAddressSpace(const android_dlextinfo* extinfo) {
ElfW(Addr) min_vaddr;
load_size_ = phdr_table_get_load_size(phdr_table_, phdr_num_, &min_vaddr);
if (load_size_ == 0) {
@ -300,11 +300,33 @@ bool ElfReader::ReserveAddressSpace() {
}
uint8_t* addr = reinterpret_cast<uint8_t*>(min_vaddr);
int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS;
void* start = mmap(addr, load_size_, PROT_NONE, mmap_flags, -1, 0);
if (start == MAP_FAILED) {
DL_ERR("couldn't reserve %zd bytes of address space for \"%s\"", load_size_, name_);
return false;
void* start;
size_t reserved_size = 0;
bool reserved_hint = true;
if (extinfo != NULL) {
if (extinfo->flags & ANDROID_DLEXT_RESERVED_ADDRESS) {
reserved_size = extinfo->reserved_size;
reserved_hint = false;
} else if (extinfo->flags & ANDROID_DLEXT_RESERVED_ADDRESS_HINT) {
reserved_size = extinfo->reserved_size;
}
}
if (load_size_ > reserved_size) {
if (!reserved_hint) {
DL_ERR("reserved address space %zd smaller than %zd bytes needed for \"%s\"",
reserved_size - load_size_, load_size_, name_);
return false;
}
int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS;
start = mmap(addr, load_size_, PROT_NONE, mmap_flags, -1, 0);
if (start == MAP_FAILED) {
DL_ERR("couldn't reserve %zd bytes of address space for \"%s\"", load_size_, name_);
return false;
}
} else {
start = extinfo->reserved_addr;
}
load_start_ = start;

4
linker/linker_phdr.h

@ -42,7 +42,7 @@ class ElfReader {
ElfReader(const char* name, int fd);
~ElfReader();
bool Load();
bool Load(const android_dlextinfo* extinfo);
size_t phdr_count() { return phdr_num_; }
ElfW(Addr) load_start() { return reinterpret_cast<ElfW(Addr)>(load_start_); }
@ -54,7 +54,7 @@ class ElfReader {
bool ReadElfHeader();
bool VerifyElfHeader();
bool ReadProgramHeader();
bool ReserveAddressSpace();
bool ReserveAddressSpace(const android_dlextinfo* extinfo);
bool LoadSegments();
bool FindPhdr();
bool CheckPhdr(ElfW(Addr));

13
tests/Android.mk

@ -188,6 +188,18 @@ build_target := SHARED_LIBRARY
include $(LOCAL_PATH)/Android.build.mk
endif
# -----------------------------------------------------------------------------
# Library used by dlext tests.
# -----------------------------------------------------------------------------
libdlext_test_src_files := \
dlext_test_library.cpp \
module := libdlext_test
module_tag := optional
build_type := target
build_target := SHARED_LIBRARY
include $(LOCAL_PATH)/Android.build.mk
# -----------------------------------------------------------------------------
# Tests for the device using bionic's .so. Run with:
# adb shell /data/nativetest/bionic-unit-tests/bionic-unit-tests
@ -196,6 +208,7 @@ bionic-unit-tests_whole_static_libraries := \
libBionicTests \
bionic-unit-tests_src_files := \
dlext_test.cpp \
dlfcn_test.cpp \
bionic-unit-tests_ldflags := \

136
tests/dlext_test.cpp Normal file

@ -0,0 +1,136 @@
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <dlfcn.h>
#include <android/dlext.h>
#include <sys/mman.h>
#define ASSERT_DL_NOTNULL(ptr) \
ASSERT_TRUE(ptr != NULL) << "dlerror: " << dlerror()
#define ASSERT_DL_ZERO(i) \
ASSERT_EQ(0, i) << "dlerror: " << dlerror()
typedef int (*fn)(void);
#define LIBNAME "libdlext_test.so"
#define LIBSIZE 1024*1024 // how much address space to reserve for it
class DlExtTest : public ::testing::Test {
protected:
virtual void SetUp() {
handle_ = NULL;
// verify that we don't have the library loaded already
ASSERT_EQ(NULL, dlsym(RTLD_DEFAULT, "getRandomNumber"));
// call dlerror() to swallow the error, and check it was the one we wanted
ASSERT_STREQ("undefined symbol: getRandomNumber", dlerror());
}
virtual void TearDown() {
if (handle_ != NULL) {
ASSERT_DL_ZERO(dlclose(handle_));
}
}
void* handle_;
};
TEST_F(DlExtTest, ExtInfoNull) {
handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, NULL);
ASSERT_DL_NOTNULL(handle_);
fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
ASSERT_DL_NOTNULL(f);
EXPECT_EQ(4, f());
}
TEST_F(DlExtTest, ExtInfoNoFlags) {
android_dlextinfo extinfo;
extinfo.flags = 0;
handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
ASSERT_DL_NOTNULL(handle_);
fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
ASSERT_DL_NOTNULL(f);
EXPECT_EQ(4, f());
}
TEST_F(DlExtTest, Reserved) {
void* start = mmap(NULL, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
ASSERT_TRUE(start != MAP_FAILED);
android_dlextinfo extinfo;
extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS;
extinfo.reserved_addr = start;
extinfo.reserved_size = LIBSIZE;
handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
ASSERT_DL_NOTNULL(handle_);
fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
ASSERT_DL_NOTNULL(f);
EXPECT_GE(f, start);
EXPECT_LT(reinterpret_cast<void*>(f),
reinterpret_cast<char*>(start) + LIBSIZE);
EXPECT_EQ(4, f());
}
TEST_F(DlExtTest, ReservedTooSmall) {
void* start = mmap(NULL, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
ASSERT_TRUE(start != MAP_FAILED);
android_dlextinfo extinfo;
extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS;
extinfo.reserved_addr = start;
extinfo.reserved_size = PAGE_SIZE;
handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
EXPECT_EQ(NULL, handle_);
}
TEST_F(DlExtTest, ReservedHint) {
void* start = mmap(NULL, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
ASSERT_TRUE(start != MAP_FAILED);
android_dlextinfo extinfo;
extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS_HINT;
extinfo.reserved_addr = start;
extinfo.reserved_size = LIBSIZE;
handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
ASSERT_DL_NOTNULL(handle_);
fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
ASSERT_DL_NOTNULL(f);
EXPECT_GE(f, start);
EXPECT_LT(reinterpret_cast<void*>(f),
reinterpret_cast<char*>(start) + LIBSIZE);
EXPECT_EQ(4, f());
}
TEST_F(DlExtTest, ReservedHintTooSmall) {
void* start = mmap(NULL, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
ASSERT_TRUE(start != MAP_FAILED);
android_dlextinfo extinfo;
extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS_HINT;
extinfo.reserved_addr = start;
extinfo.reserved_size = PAGE_SIZE;
handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
ASSERT_DL_NOTNULL(handle_);
fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
ASSERT_DL_NOTNULL(f);
EXPECT_TRUE(f < start || (reinterpret_cast<void*>(f) >=
reinterpret_cast<char*>(start) + PAGE_SIZE));
EXPECT_EQ(4, f());
}

43
tests/dlext_test_library.cpp Normal file

@ -0,0 +1,43 @@
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
class A {
public:
virtual int getRandomNumber() {
return 4; // chosen by fair dice roll.
// guaranteed to be random.
}
virtual ~A() {}
};
A a;
// nested macros to make it easy to define a large amount of read-only data
// which will require relocation.
#define A_16 &a, &a, &a, &a, &a, &a, &a, &a, &a, &a, &a, &a, &a, &a, &a, &a,
#define A_128 A_16 A_16 A_16 A_16 A_16 A_16 A_16 A_16
#define A_1024 A_128 A_128 A_128 A_128 A_128 A_128 A_128 A_128
extern "C" A* const lots_of_relro[] = {
A_1024 A_1024 A_1024 A_1024 A_1024 A_1024 A_1024 A_1024
};
extern "C" int getRandomNumber() {
// access the relro section (twice, in fact, once for the pointer, and once
// for the vtable of A) to check it's actually there.
return lots_of_relro[0]->getRandomNumber();
}