native_loader.cpp revision 34fa704df45c5f74aeb5230e4bf3930585cf32fb
1/* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "nativeloader/native_loader.h" 18#include "ScopedUtfChars.h" 19 20#include <dlfcn.h> 21#ifdef __ANDROID__ 22#include <android/dlext.h> 23#include "cutils/properties.h" 24#endif 25 26#include <algorithm> 27#include <vector> 28#include <string> 29#include <mutex> 30 31#include "android-base/macros.h" 32#include "android-base/strings.h" 33 34namespace android { 35 36#ifdef __ANDROID__ 37// TODO(dimitry): move this to system properties. 38static const char* kPublicNativeLibraries = "libandroid.so:" 39 "libc.so:" 40 "libdl.so:" 41 "libEGL.so:" 42 "libGLESv1_CM.so:" 43 "libGLESv2.so:" 44 "libGLESv3.so:" 45 "libicui18n.so:" 46 "libicuuc.so:" 47 "libjnigraphics.so:" 48 "liblog.so:" 49 "libmediandk.so:" 50 "libm.so:" 51 "libOpenMAXAL.so:" 52 "libOpenSLES.so:" 53 "libRS.so:" 54 "libstdc++.so:" 55 "libwebviewchromium_plat_support.so:" 56 "libz.so"; 57 58class LibraryNamespaces { 59 public: 60 LibraryNamespaces() : initialized_(false) { 61 PreloadPublicLibraries(); 62 } 63 64 android_namespace_t* GetOrCreate(JNIEnv* env, jobject class_loader, 65 bool is_shared, 66 jstring java_library_path, 67 jstring java_permitted_path) { 68 ScopedUtfChars library_path(env, java_library_path); 69 70 std::string permitted_path; 71 if (java_permitted_path != nullptr) { 72 ScopedUtfChars path(env, java_permitted_path); 73 permitted_path = path.c_str(); 74 } 75 76 if (!initialized_ && !InitPublicNamespace(library_path.c_str())) { 77 return nullptr; 78 } 79 80 std::lock_guard<std::mutex> guard(mutex_); 81 82 android_namespace_t* ns = FindNamespaceByClassLoader(env, class_loader); 83 84 if (ns != nullptr) { 85 return ns; 86 } 87 88 uint64_t namespace_type = ANDROID_NAMESPACE_TYPE_ISOLATED; 89 if (is_shared) { 90 namespace_type |= ANDROID_NAMESPACE_TYPE_SHARED; 91 } 92 93 ns = android_create_namespace("classloader-namespace", 94 nullptr, 95 library_path.c_str(), 96 namespace_type, 97 java_permitted_path != nullptr ? 98 permitted_path.c_str() : 99 nullptr); 100 101 namespaces_.push_back(std::make_pair(env->NewWeakGlobalRef(class_loader), ns)); 102 103 return ns; 104 } 105 106 private: 107 void PreloadPublicLibraries() { 108 // android_init_namespaces() expects all the public libraries 109 // to be loaded so that they can be found by soname alone. 110 std::vector<std::string> sonames = android::base::Split(kPublicNativeLibraries, ":"); 111 for (const auto& soname : sonames) { 112 dlopen(soname.c_str(), RTLD_NOW | RTLD_NODELETE); 113 } 114 } 115 116 bool InitPublicNamespace(const char* library_path) { 117 // Some apps call dlopen from generated code unknown to linker in which 118 // case linker uses anonymous namespace. See b/25844435 for details. 119 initialized_ = android_init_namespaces(kPublicNativeLibraries, library_path); 120 121 return initialized_; 122 } 123 124 android_namespace_t* FindNamespaceByClassLoader(JNIEnv* env, jobject class_loader) { 125 auto it = std::find_if(namespaces_.begin(), namespaces_.end(), 126 [&](const std::pair<jweak, android_namespace_t*>& value) { 127 return env->IsSameObject(value.first, class_loader); 128 }); 129 return it != namespaces_.end() ? it->second : nullptr; 130 } 131 132 bool initialized_; 133 std::mutex mutex_; 134 std::vector<std::pair<jweak, android_namespace_t*>> namespaces_; 135 136 DISALLOW_COPY_AND_ASSIGN(LibraryNamespaces); 137}; 138 139static LibraryNamespaces* g_namespaces = new LibraryNamespaces; 140#endif 141 142 143void* OpenNativeLibrary(JNIEnv* env, int32_t target_sdk_version, const char* path, 144 jobject class_loader, bool is_shared, jstring java_library_path, 145 jstring java_permitted_path) { 146#if defined(__ANDROID__) 147 if (target_sdk_version == 0 || class_loader == nullptr) { 148 return dlopen(path, RTLD_NOW); 149 } 150 151 android_namespace_t* ns = 152 g_namespaces->GetOrCreate(env, class_loader, is_shared, 153 java_library_path, java_permitted_path); 154 155 if (ns == nullptr) { 156 return nullptr; 157 } 158 159 android_dlextinfo extinfo; 160 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE; 161 extinfo.library_namespace = ns; 162 163 return android_dlopen_ext(path, RTLD_NOW, &extinfo); 164#else 165 UNUSED(env, target_sdk_version, class_loader, is_shared, 166 java_library_path, java_permitted_path); 167 return dlopen(path, RTLD_NOW); 168#endif 169} 170 171}; // android namespace 172