Android ART VM的启动流程（五）

骑猪看日落 2022-05-31 08:45 150阅读 0赞

Android系统的第一个进程是init，init通过解析init.rc脚本来启动关键的守护进程和各种系统服务－－其中包括zygote这个应用程序的孵化器。

system/core/rootdir/init.zygote64.rc（这个文件会被import进init.rc中）

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
        class main
        socket zygote stream 660 root system
        onrestart write /sys/android_power/request_state wake
        onrestart write /sys/power/state on
        onrestart restart audioserver
        onrestart restart cameraserver
        onrestart restart media
        onrestart restart netd
        writepid /dev/cpuset/foreground/tasks

进程app\_process是zygote的载体，app\_process启动后，会调用AndroidRuntime的start方法，对应源码：

frameworks/base/cmds/app\_process/app\_main.cpp

int main(int argc, char* const argv[])
    {
        if (zygote) {
            runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
        } else if (className) {
            runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
        } else {
            fprintf(stderr, "Error: no class name or --zygote supplied.\n");
            app_usage();
            return 10;
        }
    }

AndroidRuntime的start方法负责启动并管理Android虚拟机：

frameworks/base/core/jni/AndroidRuntime.cpp

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
    {
        static const String8 startSystemServer("start-system-server");
    
        /*
         * 'startSystemServer == true' means runtime is obsolete and not run from
         * init.rc anymore, so we print out the boot start event here.
         */
        for (size_t i = 0; i < options.size(); ++i) {
            if (options[i] == startSystemServer) {
               /* track our progress through the boot sequence */
               const int LOG_BOOT_PROGRESS_START = 3000;
               LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
            }
        }
    
        const char* rootDir = getenv("ANDROID_ROOT");
        if (rootDir == NULL) {
            rootDir = "/system";
            if (!hasDir("/system")) {
                LOG_FATAL("No root directory specified, and /android does not exist.");
                return;
            }
            setenv("ANDROID_ROOT", rootDir, 1);
        }
    
        //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
    
        /* start the virtual machine */
    //step1,初始化jni环境，Init函数确定启动的虚拟机是Dalvik还是ART
        JniInvocation jni_invocation;
        jni_invocation.Init(NULL);
        JNIEnv* env;
    //step2,启动虚拟机，mJavaVM代表启动后的虚拟机实例
    　　 if (startVm(&mJavaVM, &env, zygote) != 0) {
            return;
        }
    //step3,虚拟机创建成功，执行回调函数通知调用者，这里的调用者就是app_process程序，所以实际执行的是app_main.cpp中的函数
    　　 onVmCreated(env);
    
        /*
         * Register android functions.
         */
    //step4,注册native函数，都是写预设的ｊｎｉ函数
    　　 if (startReg(env) < 0) {
            ALOGE("Unable to register all android natives\n");
            return;
        }
    
        /*
         * We want to call main() with a String array with arguments in it.
         * At present we have two arguments, the class name and an option string.
         * Create an array to hold them.
         */
        jclass stringClass;
        jobjectArray strArray;
        jstring classNameStr;
    
        stringClass = env->FindClass("java/lang/String");
        assert(stringClass != NULL);
        strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
        assert(strArray != NULL);
        classNameStr = env->NewStringUTF(className);
        assert(classNameStr != NULL);
        env->SetObjectArrayElement(strArray, 0, classNameStr);
    
        for (size_t i = 0; i < options.size(); ++i) {
            jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
            assert(optionsStr != NULL);
            env->SetObjectArrayElement(strArray, i + 1, optionsStr);
        }
    
        /*
         * Start VM.  This thread becomes the main thread of the VM, and will
         * not return until the VM exits.
         */
    //ｓｔｅｐ５，执行目标对象的主函数，也即是ｚｙｇｏｔｅＩｎｉｔ的ｍａｉｎ函数
    　　 char* slashClassName = toSlashClassName(className);
        jclass startClass = env->FindClass(slashClassName);
        if (startClass == NULL) {
            ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
            /* keep going */
        } else {
            jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
                "([Ljava/lang/String;)V");
            if (startMeth == NULL) {
                ALOGE("JavaVM unable to find main() in '%s'\n", className);
                /* keep going */
            } else {
                env->CallStaticVoidMethod(startClass, startMeth, strArray);
            }
        }
        free(slashClassName);
    }

上面的函数是启动虚拟机的通用流程，不管虚拟机是Dalvik还是ART，都遵循这个方式，以实现虚拟机的兼容性。

Step1,JniInvocation.init，在虚拟机启动前，需要初始化当前的运行环境，具体由JniInvacation.init函数完成。

libnativehelp/JniInvocation.cpp

bool JniInvocation::Init(const char* library) {
    //获取虚拟机动态链接库的地址，默认值给定的是char* kLibraryFallback = "libart.so"
      library = GetLibrary(library, buffer);
      // Load with RTLD_NODELETE in order to ensure that libart.so is not unmapped when it is closed.
      // This is due to the fact that it is possible that some threads might have yet to finish
      // exiting even after JNI_DeleteJavaVM returns, which can lead to segfaults if the library is
      // unloaded.
    //打开虚拟机动态链接库
    　const int kDlopenFlags = RTLD_NOW | RTLD_NODELETE;
      handle_ = dlopen(library, kDlopenFlags);
      if (handle_ == NULL) {
        if (strcmp(library, kLibraryFallback) == 0) {
          // Nothing else to try.
          ALOGE("Failed to dlopen %s: %s", library, dlerror());
          return false;
        }
        // Note that this is enough to get something like the zygote
        // running, we can't property_set here to fix this for the future
        // because we are root and not the system user. See
        // RuntimeInit.commonInit for where we fix up the property to
        // avoid future fallbacks. http://b/11463182
        ALOGW("Falling back from %s to %s after dlopen error: %s",
              library, kLibraryFallback, dlerror());
        library = kLibraryFallback;
        handle_ = dlopen(library, kDlopenFlags);
        if (handle_ == NULL) {
          ALOGE("Failed to dlopen %s: %s", library, dlerror());
          return false;
        }
      }
    //查找虚拟机库中３个重要的接口实现
    　if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetDefaultJavaVMInitArgs_),
                      "JNI_GetDefaultJavaVMInitArgs")) {
        return false;
      }
      if (!FindSymbol(reinterpret_cast<void**>(&JNI_CreateJavaVM_),
                      "JNI_CreateJavaVM")) {
        return false;
      }
      if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetCreatedJavaVMs_),
                      "JNI_GetCreatedJavaVMs")) {
        return false;
      }
      return true;
    }

获取到library库的名称（libart.so）后,通过dlopen把他打开并加载到内存，C语言为处理动态链接库提供了一些函数，如dlopen,dlsym,dladdr等，对应的实现在bionic/linker中，dlopen是以指定的模式打开动态链接库，RTLD\_NOW表示在dlopen时直接解析所有未定义的符号，RTLD\_NODELETE表示dlclose时不卸载动态库，那么后续如果该动态库重新被加载的话，其中的静态变量就不需要重新初始化了。

然后查找３个关键的接口实现，JNI\_GetDefaultJavaVMInitArgs,JNI\_CreateJavaVM,JNI\_GetCreatedJavaVMs，分别保存在相应的变量中（JNI\_GetDefaultJavaVMInitArgs\_,JNI\_CreateJavaVM\_,JNI\_GetCreatedJavaVMs\_），这三个函数可以认为是Android虚拟机必须实现的通用接口，不管是art还是dalvik都要实现这３个接口，这样就能保证Android系统正确的使用他们。

Step2,StartVM，主要完成的工作有：

１）初始化虚拟机参数，ART跟Dalvik，JVM类似，支持一系列的配置参数，这些参数的默认值通常来自于系统属性，相关代码：

parseRuntimeOption("dalvik.vm.heapsize", heapsizeOptsBuf, "-Xmx", "16m");

parseCompilerRuntimeOption("dalvik.vm.dex2oat-Xms", dex2oatXmsFlagsBuf, "-Xms", "-Xcompiler-option");

２）StartVM的最后，调用JNI\_CreateJavaVM，前面设置的启动参数会保存在变量nOptions中，然后通过JNI\_CreateJavaVM这一标准接口传递给具体的虚拟机实现。JNI\_CreateJavaVM成功返回，虚拟机就处于就绪状态了，可以接受jni调用了。

虚拟机分为java和native两个层面，这两层间的通信就是jni，通常虚拟机的创建和管理都是在native层，然后通过jni来与java层互访，JNI\_CreateJavaVM成功执行后，会有一个JNIEnv类型的指针变量，就是pEnv，他是以指向指针的指针做为参数的。这个JNIEnv指针是访问JVM的关键，真正的实现是JNIEnvExt。

art/runtime/jni\_env\_ext.h ,从这里可以看出实现关系

struct JNIEnvExt : public JNIEnv {
      static JNIEnvExt* Create(Thread* self, JavaVMExt* vm);
    
      ~JNIEnvExt();
    }

Step3,onVmCreated，虚拟机成功创建完成，需要通过回调函数onVmCreate()通知用户，这里的调用者就是AndroidRuntime的继承类AppRuntime，

Step4,startReg，为虚拟机注册本地函数，

frameworks/base/core/jni/AndroidRuntime.cpp

int AndroidRuntime::startReg(JNIEnv* env)
    {
        ATRACE_NAME("RegisterAndroidNatives");
        /*
         * This hook causes all future threads created in this process to be
         * attached to the JavaVM.  (This needs to go away in favor of JNI
         * Attach calls.)
         */
       //这个调用会让后面创建的新线程都会ｈｏｏｋｅｄ到ＪａｖａＶＭ上。
        androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
    
        ALOGV("--- registering native functions ---\n");
    
        /*
         * Every "register" function calls one or more things that return
         * a local reference (e.g. FindClass).  Because we haven't really
         * started the VM yet, they're all getting stored in the base frame
         * and never released.  Use Push/Pop to manage the storage.
         */
    //ＰｕｓｈＬｏｃａｌＦｒａｍｅ，ＰｏｐＬｏｃａｌＦｒａｍｅ的作用是管理局部引用的生命周期，要配套使用。
        env->PushLocalFrame(200);
    
        if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
            env->PopLocalFrame(NULL);
            return -1;
        }
        env->PopLocalFrame(NULL);
    
        //createJavaThread("fubar", quickTest, (void*) "hello");
    
        return 0;
    }

static const RegJNIRec gRegJNI[] = {
        REG_JNI(register_android_util_SeempLog),
        REG_JNI(register_com_android_internal_os_RuntimeInit),
        REG_JNI(register_android_os_SystemClock),
        REG_JNI(register_android_util_EventLog),
        REG_JNI(register_android_util_Log),
        REG_JNI(register_android_util_MemoryIntArray),
        REG_JNI(register_android_util_PathParser),
        REG_JNI(register_android_app_admin_SecurityLog),
    ......

注册的过程是分别调用gRegJNI数组中每个元素，展开REG\_JNI宏定义，实际执行的就是REG\_JNI()括号中的函数，通过AndroidRuntime，这个函数最终会调用Java虚拟机中的RegisterNativeMethods方法，注册的过程就是把Java层的函数跟本地层的实现建立关联，这些java层函数和native函数的映射关系以JNINativeMethod gMethods\[\]数组来定义的，

typedef struct {
        const char* name;
        const char* signature;
        void*       fnPtr;
    } JNINativeMethod;

宏定义REG\_JNI中的每个函数都有一个这样的数组。从JNI的实现看，JVM所做的工作就是把这写本地函数设置为ArtMethod的JNI入口。

step5,AndroidRuntime::start的第五步，调用zygoteInit.java的main函数，正式启动一个Java程序。