Android JNI开辟：System.loadLibrary加载机制

源码流程分析

在Android的JNI开辟中，加载.so文件通常使用System.loadLibrary函数。以下是一个简单的示例：

1. public class MainActivity extends AppCompatActivity {
2.     // Used to load the 'myapplication' library on application startup.
3.     static {
4.         System.loadLibrary("myapplication");
5.     }
6. }

复制代码

接下来，我们以Android 10的源码为例，详细分析System.loadLibrary函数的实现过程。起首，System.loadLibrary的定义位于/libcore/ojluni/src/main/java/java/lang/System.java，实现如下：

1. public static void loadLibrary(String libname) {
2.          Runtime.getRuntime().loadLibrary0(Reflection.getCallerClass(), libname);
3. }

复制代码

从中可以看出，System.loadLibrary实际上是调用了Runtime类的loadLibrary0方法。我们继承跟踪loadLibrary0的实现：

1. void loadLibrary0(Class<?> fromClass, String libname) {
2.     ClassLoader classLoader = ClassLoader.getClassLoader(fromClass);
3.     loadLibrary0(classLoader, fromClass, libname);
4. }

复制代码

在这里，通过传入的类获取了对应的类加载器（ClassLoader），然后调用了重载的loadLibrary0方法：

1. private synchronized void loadLibrary0(ClassLoader loader, Class<?> callerClass, String libname) {
2.     // Check if the library name contains a directory separator
3.     if (libname.indexOf((int) File.separatorChar) != -1) {
4.         throw new UnsatisfiedLinkError(
5.             "Directory separator should not appear in library name: " + libname);
6.     }
7.    
8.     String libraryName = libname;
10.     // If loader is not null and not BootClassLoader, use it to find the library
11.     if (loader != null && !(loader instanceof BootClassLoader)) {
12.         String filename = loader.findLibrary(libraryName);
13.         if (filename == null) {
14.             throw new UnsatisfiedLinkError(loader + " couldn't find "" +
15.                                            System.mapLibraryName(libraryName) + """);
16.         }
17.         String error = nativeLoad(filename, loader);
18.         if (error != null) {
19.             throw new UnsatisfiedLinkError(error);
20.         }
21.         return;
22.     }
24.     // If loader is null or is BootClassLoader, initialize library paths and load the library
25.     getLibPaths();
26.     String filename = System.mapLibraryName(libraryName);
27.     String error = nativeLoad(filename, loader, callerClass);
28.     if (error != null) {
29.         throw new UnsatisfiedLinkError(error);
30.     }
31. }

复制代码

这里loadLibrary0有一句关键代码：

1. oader.findLibrary：
2. public String findLibrary(String name) {
3.          return pathList.findLibrary(name);
4. }

复制代码

实现如下：

1. public String findLibrary(String libraryName) {
2.         // 最后会调用到C层中JNIEXPORT jstring JNICALL System_mapLibraryName(JNIEnv *env, jclass ign, jstring libname)
3.         // 结果就是会返回libmyapplication.so，拼接字符串
4.     String fileName = System.mapLibraryName(libraryName);
5.         // 返回libmyapplication.so的全路径
6.     for (NativeLibraryElement element : nativeLibraryPathElements) {
7.         String path = element.findNativeLibrary(fileName);
9.         if (path != null) {
10.             return path;
11.         }
12.     }
14.     return null;
15. }

复制代码

可以看到，findLibrary最终会通过JNI调用System.mapLibraryName方法拼接出完备的.so库文件名，并在本地路径中查找该文件。
接着看loadLibrary0中nativeLoad实现：

1. private static native String nativeLoad(String filename, ClassLoader loader, Class<?> caller);

复制代码

发现此时已经在C层，实现如下：

1. JNIEXPORT jstring JNICALL Runtime_nativeLoad(JNIEnv* env, jclass ignored, jstring javaFilename,
2.                     jobject javaLoader, jclass caller)
3. {
4.     return JVM_NativeLoad(env, javaFilename, javaLoader, caller);
5. }

复制代码

看来核心代码在JVM_NativeLoad函数中，继承跟进：

1. JNIEXPORT jstring JVM_NativeLoad(JNIEnv* env,
2.                                   jstring javaFilename,
3.                                   jobject javaLoader,
4.                                   jclass caller) {
5.     ScopedUtfChars filename(env, javaFilename);
6.     if (filename.c_str() == nullptr) {
7.         return nullptr;
8.     }
10.     std::string error_msg;
11.     {
12.         art::JavaVMExt* vm = art::Runtime::Current()->GetJavaVM();
13.         bool success = vm->LoadNativeLibrary(env,
14.                                               filename.c_str(),
15.                                               javaLoader,
16.                                               caller,
17.                                               &error_msg);
18.         if (success) {
19.             return nullptr;
20.         }
21.     }
23.     // Don't let a pending exception from JNI_OnLoad cause a CheckJNI issue with NewStringUTF.
24.     env->ExceptionClear();
25.     return env->NewStringUTF(error_msg.c_str());
26. }

复制代码

vm->LoadNativeLibrary函数相对复杂，我们主要查看在这个函数内部调用android::OpenNativeLibrary函数：

1. void* OpenNativeLibrary(JNIEnv* env, int32_t target_sdk_version, const char* path,
2.                         jobject class_loader, const char* caller_location, jstring library_path,
3.                         bool* needs_native_bridge, char** error_msg) {
4. #if defined(__ANDROID__)
5.     UNUSED(target_sdk_version);
6.     if (class_loader == nullptr) {
7.         *needs_native_bridge = false;
8.         if (caller_location != nullptr) {
9.             android_namespace_t* boot_namespace = FindExportedNamespace(caller_location);
10.             if (boot_namespace != nullptr) {
11.                 const android_dlextinfo dlextinfo = {
12.                     .flags = ANDROID_DLEXT_USE_NAMESPACE,
13.                     .library_namespace = boot_namespace,
14.                 };
15.                 void* handle = android_dlopen_ext(path, RTLD_NOW, &dlextinfo);
16.                 if (handle == nullptr) {
17.                     *error_msg = strdup(dlerror());
18.                 }
19.                 return handle;
20.             }
21.         }
22.         void* handle = dlopen(path, RTLD_NOW);
23.         if (handle == nullptr) {
24.             *error_msg = strdup(dlerror());
25.         }
26.         return handle;
27.     }
28.     // Additional code (not provided) would go here
29. #endif
30. }

复制代码

总算追踪到了我们的老朋侪android_dlopen_ext和dlopen，最后经过追踪会调用do_dlopen函数，这就到本日的核心：

1. void* do_dlopen(const char* name, int flags,const android_dlextinfo* extinfo,const void* caller_addr) {
2.         ...
3.         ProtectedDataGuard guard;
4. soinfo* si = find_library(ns, translated_name, flags, extinfo, caller);
5. loading_trace.End();
7. if (si != nullptr) {
8.     void* handle = si->to_handle();
9.     LD_LOG(kLogDlopen,
10.            "... dlopen calling constructors: realpath="%s", soname="%s", handle=%p",
11.            si->get_realpath(), si->get_soname(), handle);
12.     si->call_constructors();
13.     failure_guard.Disable();
14.     LD_LOG(kLogDlopen,
15.            "... dlopen successful: realpath="%s", soname="%s", handle=%p",
16.            si->get_realpath(), si->get_soname(), handle);
17.     return handle;
18. }

复制代码

也就是在在so加载完成以后会调用si->call_constructors()函数：

1. void soinfo::call_constructors() {
2.         // 主要看这样两行
3.     call_function("DT_INIT", init_func_, get_realpath());
4.     call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false, get_realpath());
5. }

复制代码

这里也就阐明白so中的init和init_array的实行时机在do_dlopen内部。此外，我们还需要相识JNI_OnLoad的实行时机。回到vm->LoadNativeLibrary函数中：

1. bool JavaVMExt::LoadNativeLibrary(JNIEnv* env,
2.                                   const std::string& path,
3.                                   jobject class_loader,
4.                                   jclass caller_class,
5.                                   std::string* error_msg) {
6.                                  
7. void* sym = library->FindSymbol("JNI_OnLoad", nullptr);
8. if (sym == nullptr) {
9.     VLOG(jni) << "[No JNI_OnLoad found in "" << path << ""]";
10.     was_successful = true;
11. } else {
12.     ScopedLocalRef<jobject> old_class_loader(env, env->NewLocalRef(self->GetClassLoaderOverride()));
13.     self->SetClassLoaderOverride(class_loader);
15.     VLOG(jni) << "[Calling JNI_OnLoad in "" << path << ""]";
16.     using JNI_OnLoadFn = int(*)(JavaVM*, void*);
17.     JNI_OnLoadFn jni_on_load = reinterpret_cast<JNI_OnLoadFn>(sym);
18.     int version = (*jni_on_load)(this, nullptr);
19. }

复制代码

可以看到就是通过library->FindSymbol查找JNI_OnLoad符号，然后使用函数指针进行JNI_OnLoad的函数调用。
总结

System.loadLibrary的核心功能是获取.so库的全路径，加载该.so库文件，然后依次调用init、init_array和JNI_OnLoad函数。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。