// Copyright 2015 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // This is the Android-specific Chromium linker, a tiny shared library // implementing a custom dynamic linker that can be used to load the // real Chromium libraries. // The main point of this linker is to be able to share the RELRO // section of libcontentshell.so (or equivalent) between the browser and // renderer process. // This source code *cannot* depend on anything from base/ or the C++ // STL, to keep the final library small, and avoid ugly dependency issues. #ifndef BASE_ANDROID_LINKER_LINKER_JNI_H_ #define BASE_ANDROID_LINKER_LINKER_JNI_H_ #include #include #include #include #include "build/build_config.h" // Set this to 1 to enable debug traces to the Android log. // Note that LOG() from "base/logging.h" cannot be used, since it is // in base/ which hasn't been loaded yet. #define DEBUG 0 #define TAG "cr_ChromiumAndroidLinker" #if DEBUG #define LOG_INFO(FORMAT, ...) \ __android_log_print(ANDROID_LOG_INFO, TAG, "%s: " FORMAT, __FUNCTION__, \ ##__VA_ARGS__) #else #define LOG_INFO(FORMAT, ...) ((void)0) #endif #define LOG_ERROR(FORMAT, ...) \ __android_log_print(ANDROID_LOG_ERROR, TAG, "%s: " FORMAT, __FUNCTION__, \ ##__VA_ARGS__) #define UNUSED __attribute__((unused)) #if defined(ARCH_CPU_X86) // Dalvik JIT generated code doesn't guarantee 16-byte stack alignment on // x86 - use force_align_arg_pointer to realign the stack at the JNI // boundary. https://crbug.com/655248 #define JNI_GENERATOR_EXPORT \ extern "C" __attribute__((visibility("default"), force_align_arg_pointer)) #else #define JNI_GENERATOR_EXPORT extern "C" __attribute__((visibility("default"))) #endif #if defined(__arm__) && defined(__ARM_ARCH_7A__) #define CURRENT_ABI "armeabi-v7a" #elif defined(__arm__) #define CURRENT_ABI "armeabi" #elif defined(__i386__) #define CURRENT_ABI "x86" #elif defined(__mips__) #define CURRENT_ABI "mips" #elif defined(__x86_64__) #define CURRENT_ABI "x86_64" #elif defined(__aarch64__) #define CURRENT_ABI "arm64-v8a" #else #error "Unsupported target abi" #endif namespace chromium_android_linker { // Larger than the largest library we might attempt to load. static const size_t kAddressSpaceReservationSize = 192 * 1024 * 1024; // A simple scoped UTF String class that can be initialized from // a Java jstring handle. Modeled like std::string, which cannot // be used here. class String { public: String(JNIEnv* env, jstring str); inline ~String() { ::free(ptr_); } inline const char* c_str() const { return ptr_ ? ptr_ : ""; } inline size_t size() const { return size_; } private: char* ptr_; size_t size_; }; // Return true iff |address| is a valid address for the target CPU. inline bool IsValidAddress(jlong address) { return static_cast(static_cast(address)) == address; } // Find the jclass JNI reference corresponding to a given |class_name|. // |env| is the current JNI environment handle. // On success, return true and set |*clazz|. extern bool InitClassReference(JNIEnv* env, const char* class_name, jclass* clazz); // Initialize a jfieldID corresponding to the field of a given |clazz|, // with name |field_name| and signature |field_sig|. // |env| is the current JNI environment handle. // On success, return true and set |*field_id|. extern bool InitFieldId(JNIEnv* env, jclass clazz, const char* field_name, const char* field_sig, jfieldID* field_id); // Initialize a jfieldID corresponding to the static field of a given |clazz|, // with name |field_name| and signature |field_sig|. // |env| is the current JNI environment handle. // On success, return true and set |*field_id|. extern bool InitStaticFieldId(JNIEnv* env, jclass clazz, const char* field_name, const char* field_sig, jfieldID* field_id); // Use Android ASLR to create a random library load address. // |env| is the current JNI environment handle, and |clazz| a class. // Returns the address selected by ASLR. extern jlong GetRandomBaseLoadAddress(JNIEnv* env, jclass clazz); // A class used to model the field IDs of the org.chromium.base.Linker // LibInfo inner class, used to communicate data with the Java side // of the linker. struct LibInfo_class { jfieldID load_address_id; jfieldID load_size_id; jfieldID relro_start_id; jfieldID relro_size_id; jfieldID relro_fd_id; // Initialize an instance. bool Init(JNIEnv* env) { jclass clazz; if (!InitClassReference( env, "org/chromium/base/library_loader/Linker$LibInfo", &clazz)) { return false; } return InitFieldId(env, clazz, "mLoadAddress", "J", &load_address_id) && InitFieldId(env, clazz, "mLoadSize", "J", &load_size_id) && InitFieldId(env, clazz, "mRelroStart", "J", &relro_start_id) && InitFieldId(env, clazz, "mRelroSize", "J", &relro_size_id) && InitFieldId(env, clazz, "mRelroFd", "I", &relro_fd_id); } void SetLoadInfo(JNIEnv* env, jobject library_info_obj, size_t load_address, size_t load_size) { env->SetLongField(library_info_obj, load_address_id, load_address); env->SetLongField(library_info_obj, load_size_id, load_size); } void SetRelroInfo(JNIEnv* env, jobject library_info_obj, size_t relro_start, size_t relro_size, int relro_fd) { env->SetLongField(library_info_obj, relro_start_id, relro_start); env->SetLongField(library_info_obj, relro_size_id, relro_size); env->SetIntField(library_info_obj, relro_fd_id, relro_fd); } // Use this instance to convert a RelroInfo reference into // a crazy_library_info_t. void GetRelroInfo(JNIEnv* env, jobject library_info_obj, size_t* relro_start, size_t* relro_size, int* relro_fd) { if (relro_start) { *relro_start = static_cast( env->GetLongField(library_info_obj, relro_start_id)); } if (relro_size) { *relro_size = static_cast( env->GetLongField(library_info_obj, relro_size_id)); } if (relro_fd) { *relro_fd = env->GetIntField(library_info_obj, relro_fd_id); } } }; // Variable containing LibInfo for the loaded library. extern LibInfo_class s_lib_info_fields; } // namespace chromium_android_linker #endif // BASE_ANDROID_LINKER_LINKER_JNI_H_