Dalvik学习笔记--启动过程

学习老罗的博客，顺便记点笔记，强化记忆

代码用的4.3，与老罗不一样的地方会标注出来

从AndroidRuntime.start开始

void AndroidRuntime::start(const char* className, const char* options){    ......    /* start the virtual machine */    JNIEnv* env;    if (startVm(&mJavaVM, &env) != 0) {        return;    }    onVmCreated(env);<span style="white-space:pre"></span>//此函数为空函数，原文注释：If AndroidRuntime had anything to do here, we'd have done it in 'start'.    /*     * Register android functions.     */    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;    jstring optionsStr;    stringClass = env->FindClass("java/lang/String");<span style="white-space:pre">    assert(stringClass != NULL);    strArray = env->NewObjectArray(2, stringClass, NULL);    assert(strArray != NULL);    classNameStr = env->NewStringUTF(className);    assert(classNameStr != NULL);    env->SetObjectArrayElement(strArray, 0, classNameStr);<span style="white-space:pre"></span>//构造2个元素的String数组    optionsStr = env->NewStringUTF(options);<span style="white-space:pre"></span>//第一个元素为类名    env->SetObjectArrayElement(strArray, 1, optionsStr);<span style="white-space:pre"></span>//第二个为设置    /*     * Start VM.  This thread becomes the main thread of the VM, and will     * not return until the VM exits.     */    char* slashClassName = toSlashClassName(className);<span style="white-space:pre"></span>//将字符串中的 . 替换为 /    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");<span style="white-space:pre"></span>//获取main方法的id        if (startMeth == NULL) {            ALOGE("JavaVM unable to find main() in '%s'\n", className);            /* keep going */        } else {            env->CallStaticVoidMethod(startClass, startMeth, strArray);<span style="white-space:pre"></span>//调用main方法    ......}

GetStaticMethodID函数用于获取方法id，一个参数为目标类，第二个为方法名，第三个是参数描述（是不是很像smali代码）

CallStaticVoidMethod函数第一个参数为目标类，第二个为方法id，第三个是可变参数

这里有个小小的变化就是toSlashClassName将原来的几行代码封装了一下。

实例创建startVm函数

该函数很长，但是大致可以分为三部分

int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv){    int result = -1;    JavaVMInitArgs initArgs;    JavaVMOption opt;    char propBuf[PROPERTY_VALUE_MAX];    char stackTraceFileBuf[PROPERTY_VALUE_MAX];    char dexoptFlagsBuf[PROPERTY_VALUE_MAX];    char enableAssertBuf[sizeof("-ea:")-1 + PROPERTY_VALUE_MAX];    char jniOptsBuf[sizeof("-Xjniopts:")-1 + PROPERTY_VALUE_MAX];    char heapstartsizeOptsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX];    char heapsizeOptsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];    char heapgrowthlimitOptsBuf[sizeof("-XX:HeapGrowthLimit=")-1 + PROPERTY_VALUE_MAX];    char heapminfreeOptsBuf[sizeof("-XX:HeapMinFree=")-1 + PROPERTY_VALUE_MAX];    char heapmaxfreeOptsBuf[sizeof("-XX:HeapMaxFree=")-1 + PROPERTY_VALUE_MAX];    char heaptargetutilizationOptsBuf[sizeof("-XX:HeapTargetUtilization=")-1 + PROPERTY_VALUE_MAX];    char extraOptsBuf[PROPERTY_VALUE_MAX];    char* stackTraceFile = NULL;    bool checkJni = false;    bool checkDexSum = false;    bool logStdio = false;    enum {      kEMDefault,      kEMIntPortable,      kEMIntFast,      kEMJitCompiler,    } executionMode = kEMDefault;

先声明字符串用于存放配置信息，声明标志变量

    property_get("dalvik.vm.checkjni", propBuf, "");    if (strcmp(propBuf, "true") == 0) {        checkJni = true;    } else if (strcmp(propBuf, "false") != 0) {        /* property is neither true nor false; fall back on kernel parameter */        property_get("ro.kernel.android.checkjni", propBuf, "");        if (propBuf[0] == '1') {            checkJni = true;        }    }    ......    /* Force interpreter-only mode for selected methods */    char jitMethodBuf[sizeof("-Xjitmethod:") + PROPERTY_VALUE_MAX];    property_get("dalvik.vm.jit.method", propBuf, "");    if (strlen(propBuf) > 0) {        strcpy(jitMethodBuf, "-Xjitmethod:");        strcat(jitMethodBuf, propBuf);        opt.optionString = jitMethodBuf;        mOptions.add(opt);    }

第二部分大多都是上述这种形式，先用property_get函数，在之前声明的字符串中存放配置信息，比较后设置对应的标志变量

比如在propBuf中存放dalvik.vm.checkjni的信息，如果propBuf字符串为“true”，就将checkJni设置为true

    if (executionMode == kEMIntPortable) {        opt.optionString = "-Xint:portable";        mOptions.add(opt);    } else if (executionMode == kEMIntFast) {        opt.optionString = "-Xint:fast";        mOptions.add(opt);    } else if (executionMode == kEMJitCompiler) {        opt.optionString = "-Xint:jit";        mOptions.add(opt);    }    if (checkDexSum) {        /* perform additional DEX checksum tests */        opt.optionString = "-Xcheckdexsum";        mOptions.add(opt);    }    ......

再根据这些标志变量进行设置。

    /*     * Initialize the VM.     *     * The JavaVM* is essentially per-process, and the JNIEnv* is per-thread.     * If this call succeeds, the VM is ready, and we can start issuing     * JNI calls.     */    if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {        ALOGE("JNI_CreateJavaVM failed\n");        goto bail;    }

当然最后调用JNI_CreateJavaVM函数。

/* * Create a new VM instance. * * The current thread becomes the main VM thread.  We return immediately, * which effectively means the caller is executing in a native method. */jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void* vm_args) {    const JavaVMInitArgs* args = (JavaVMInitArgs*) vm_args;    if (args->version < JNI_VERSION_1_2) {        return JNI_EVERSION;    }    // TODO: don't allow creation of multiple VMs -- one per customer for now    /* zero globals; not strictly necessary the first time a VM is started */    memset(&gDvm, 0, sizeof(gDvm));    /*     * Set up structures for JNIEnv and VM.     */    JavaVMExt* pVM = (JavaVMExt*) calloc(1, sizeof(JavaVMExt));    pVM->funcTable = &gInvokeInterface;    pVM->envList = NULL;    dvmInitMutex(&pVM->envListLock);    UniquePtr<const char*[]> argv(new const char*[args->nOptions]);    memset(argv.get(), 0, sizeof(char*) * (args->nOptions));    /*     * Convert JNI args to argv.     *     * We have to pull out vfprintf/exit/abort, because they use the     * "extraInfo" field to pass function pointer "hooks" in.  We also     * look for the -Xcheck:jni stuff here.     */    int argc = 0;    for (int i = 0; i < args->nOptions; i++) {<span style="white-space:pre"></span>//收集虚拟机相关信息        const char* optStr = args->options[i].optionString;        if (optStr == NULL) {            dvmFprintf(stderr, "ERROR: CreateJavaVM failed: argument %d was NULL\n", i);            return JNI_ERR;        } else if (strcmp(optStr, "vfprintf") == 0) {            gDvm.vfprintfHook = (int (*)(FILE *, const char*, va_list))args->options[i].extraInfo;        } else if (strcmp(optStr, "exit") == 0) {            gDvm.exitHook = (void (*)(int)) args->options[i].extraInfo;        } else if (strcmp(optStr, "abort") == 0) {            gDvm.abortHook = (void (*)(void))args->options[i].extraInfo;        } else if (strcmp(optStr, "sensitiveThread") == 0) {            gDvm.isSensitiveThreadHook = (bool (*)(void))args->options[i].extraInfo;        } else if (strcmp(optStr, "-Xcheck:jni") == 0) {            gDvmJni.useCheckJni = true;        } else if (strncmp(optStr, "-Xjniopts:", 10) == 0) {            char* jniOpts = strdup(optStr + 10);            size_t jniOptCount = 1;            for (char* p = jniOpts; *p != 0; ++p) {                if (*p == ',') {                    ++jniOptCount;                    *p = 0;                }            }            char* jniOpt = jniOpts;            for (size_t i = 0; i < jniOptCount; ++i) {                if (strcmp(jniOpt, "warnonly") == 0) {                    gDvmJni.warnOnly = true;                } else if (strcmp(jniOpt, "forcecopy") == 0) {                    gDvmJni.forceCopy = true;                } else if (strcmp(jniOpt, "logThirdPartyJni") == 0) {                    gDvmJni.logThirdPartyJni = true;                } else {                    dvmFprintf(stderr, "ERROR: CreateJavaVM failed: unknown -Xjniopts option '%s'\n",                            jniOpt);                    return JNI_ERR;                }                jniOpt += strlen(jniOpt) + 1;            }            free(jniOpts);        } else {            /* regular option */            argv[argc++] = optStr;        }    }    if (gDvmJni.useCheckJni) {        dvmUseCheckedJniVm(pVM);    }    if (gDvmJni.jniVm != NULL) {        dvmFprintf(stderr, "ERROR: Dalvik only supports one VM per process\n");        return JNI_ERR;    }    gDvmJni.jniVm = (JavaVM*) pVM;    /*     * Create a JNIEnv for the main thread.  We need to have something set up     * here because some of the class initialization we do when starting     * up the VM will call into native code.     */    JNIEnvExt* pEnv = (JNIEnvExt*) dvmCreateJNIEnv(NULL);    /* Initialize VM. */    gDvm.initializing = true;    std::string status =            dvmStartup(argc, argv.get(), args->ignoreUnrecognized, (JNIEnv*)pEnv);<span style="white-space:pre"></span>//初始化虚拟机，关键函数，其他代码都是为他的参数做准备    gDvm.initializing = false;    if (!status.empty()) {        free(pEnv);        free(pVM);        ALOGW("CreateJavaVM failed: %s", status.c_str());        return JNI_ERR;    }    /*     * Success!  Return stuff to caller.     */    dvmChangeStatus(NULL, THREAD_NATIVE);    *p_env = (JNIEnv*) pEnv;    *p_vm = (JavaVM*) pVM;    ALOGV("CreateJavaVM succeeded");    return JNI_OK;}

代码注释很全，简单说一下。先给一个虚拟机实例分配空间，初始化需要切换当前线程状态，需要保存设置和创建一个运行环境，gDvm就是用来收集虚拟机信息的全局变量（给实例分配的空间也保存在当中），用于在不同线程状态间传递虚拟机实例，argv保存从vm_args传递过来的参数，通过这个几个变量就可以切换线程状态创建虚拟机实例。创建完成后再通过dvmChangeStatus切换回去（Return stuff to caller）。然后将实例（pVM）和环境（pEnv）传递给调用者。

上述提到的DvmGlobals结构体定义文件dalvik/vm/Globals.h中，JNIInvokeInterface结构体定义在文件dalvik/libnativehelper/include/nativehelper/jni.h中，JavaVMExt和JNIEnvExt结构体定义在文件dalvik/vm/JniInternal.h中。

接下来是dvmCreateJNIEnv函数

JNIEnv* dvmCreateJNIEnv(Thread* self) {    JavaVMExt* vm = (JavaVMExt*) gDvmJni.jniVm;    //if (self != NULL)    //    ALOGI("Ent CreateJNIEnv: threadid=%d %p", self->threadId, self);    assert(vm != NULL);    JNIEnvExt* newEnv = (JNIEnvExt*) calloc(1, sizeof(JNIEnvExt));<span style="white-space:pre"></span>//创建一个JNIEnvExt对象    newEnv->funcTable = &gNativeInterface;<span style="white-space:pre"></span>//设置本地借口表    if (self != NULL) {<span style="white-space:pre"></span>//self表示所要关联的线程        dvmSetJniEnvThreadId((JNIEnv*) newEnv, self);<span style="white-space:pre"></span>//设置关联的函数        assert(newEnv->envThreadId != 0);    } else {        /* make it obvious if we fail to initialize these later */        newEnv->envThreadId = 0x77777775;<span style="white-space:pre"></span>//表示还未与线程关联        newEnv->self = (Thread*) 0x77777779;    }    if (gDvmJni.useCheckJni) {        dvmUseCheckedJniEnv(newEnv);    }    ScopedPthreadMutexLock lock(&vm->envListLock);    /* insert at head of list */    newEnv->next = vm->envList;<span style="white-space:pre"></span>//newEnv的宿主虚拟机是vm，也就是之前创建的实例    assert(newEnv->prev == NULL);    if (vm->envList == NULL) {<span style="white-space:pre"></span>//将newEnv插入到vm->envList链表中        // rare, but possible        vm->envList = newEnv;    } else {        vm->envList->prev = newEnv;    }    vm->envList = newEnv;    //if (self != NULL)    //    ALOGI("Xit CreateJNIEnv: threadid=%d %p", self->threadId, self);    return (JNIEnv*) newEnv;}

 在一个Dalvik虚拟机里面，可以运行多个线程。所有关联有JNI环境的线程都有一个对应的JNIEnvExt对象，这些JNIEnvExt对象相互连接在一起保存在用来描述其宿主Dalvik虚拟机的一个JavaVMExt对象的成员变量envList中。因此，前面创建的JNIEnvExt对象需要连接到其宿主Dalvik虚拟机的JavaVMExt链表中去。
再看dvmStartup函数

std::string dvmStartup(int argc, const char* const argv[],        bool ignoreUnrecognized, JNIEnv* pEnv){    ScopedShutdown scopedShutdown;    assert(gDvm.initializing);    ALOGV("VM init args (%d):", argc);    for (int i = 0; i < argc; i++) {        ALOGV("  %d: '%s'", i, argv[i]);    }    setCommandLineDefaults();<span style="white-space:pre"></span>//设置默认项    /*     * Process the option flags (if any).     */    int cc = processOptions(argc, argv, ignoreUnrecognized);<span style="white-space:pre"></span>//处理启动选项    if (cc != 0) {        if (cc < 0) {            dvmFprintf(stderr, "\n");            usage("dalvikvm");        }        return "syntax error";    }

与老罗代码相比没有了dvmPropertiesStartup来分配空间

    /*     * Initialize components.     */    dvmQuasiAtomicsStartup();    if (!dvmAllocTrackerStartup()) {<span style="white-space:pre"></span>//对象分配记录子模块        return "dvmAllocTrackerStartup failed";    }    if (!dvmGcStartup()) {<span style="white-space:pre"></span>//GC子模块        return "dvmGcStartup failed";    }    if (!dvmThreadStartup()) {<span style="white-space:pre"></span>//线程列表        return "dvmThreadStartup failed";    }    if (!dvmInlineNativeStartup()) {<span style="white-space:pre"></span>//内建Native函数表        return "dvmInlineNativeStartup";    }    if (!dvmRegisterMapStartup()) {<span style="white-space:pre"></span>//寄存器映射集        return "dvmRegisterMapStartup failed";    }    if (!dvmInstanceofStartup()) {<span style="white-space:pre"></span>//实例操作符子模块        return "dvmInstanceofStartup failed";    }    if (!dvmClassStartup()) {<span style="white-space:pre"></span>//启动类加载器        return "dvmClassStartup failed";    }    /*     * At this point, the system is guaranteed to be sufficiently     * initialized that we can look up classes and class members. This     * call populates the gDvm instance with all the class and member     * references that the VM wants to use directly.     */    if (!dvmFindRequiredClassesAndMembers()) {<span style="white-space:pre"></span>//重要类和函数        return "dvmFindRequiredClassesAndMembers failed";    }    if (!dvmStringInternStartup()) {<span style="white-space:pre"></span>//字符串池        return "dvmStringInternStartup failed";    }    if (!dvmNativeStartup()) {<span style="white-space:pre"></span>//so库加载表        return "dvmNativeStartup failed";    }    if (!dvmInternalNativeStartup()) {<span style="white-space:pre"></span>//内部Native函数表        return "dvmInternalNativeStartup failed";    }    if (!dvmJniStartup()) {<span style="white-space:pre"></span>//全局引用表        return "dvmJniStartup failed";    }    if (!dvmProfilingStartup()) {<span style="white-space:pre"></span>//性能分析子模块        return "dvmProfilingStartup failed";    }    /*     * Create a table of methods for which we will substitute an "inline"     * version for performance.     */    if (!dvmCreateInlineSubsTable()) {<span style="white-space:pre"></span>//内联函数表        return "dvmCreateInlineSubsTable failed";    }    /*     * Miscellaneous class library validation.     */    if (!dvmValidateBoxClasses()) {<span style="white-space:pre"></span>//验证虚拟机中相应的装箱类        return "dvmValidateBoxClasses failed";    }    /*     * Do the last bits of Thread struct initialization we need to allow     * JNI calls to work.     */    if (!dvmPrepMainForJni(pEnv)) {<span style="white-space:pre"></span>//准备主线程JNI环境        return "dvmPrepMainForJni failed";    }    /*     * Explicitly initialize java.lang.Class.  This doesn't happen     * automatically because it's allocated specially (it's an instance     * of itself).  Must happen before registration of system natives,     * which make some calls that throw assertions if the classes they     * operate on aren't initialized.     */    if (!dvmInitClass(gDvm.classJavaLangClass)) {//确保目标类初始化        return "couldn't initialized java.lang.Class";    }    /*     * Register the system native methods, which are registered through JNI.     */    if (!registerSystemNatives(pEnv)) {<span style="white-space:pre"></span>//为JAVA核心类注册JNI方法        return "couldn't register system natives";    }    /*     * Do some "late" initialization for the memory allocator.  This may     * allocate storage and initialize classes.     */    if (!dvmCreateStockExceptions()) {<span style="white-space:pre"></span>//预创建与内存相关的异样对象        return "dvmCreateStockExceptions failed";    }    /*     * At this point, the VM is in a pretty good state.  Finish prep on     * the main thread (specifically, create a java.lang.Thread object to go     * along with our Thread struct).  Note we will probably be executing     * some interpreted class initializer code in here.     */    if (!dvmPrepMainThread()) {<span style="white-space:pre"></span>//为主线程创建ThreadGroup对象        return "dvmPrepMainThread failed";    }    /*     * Make sure we haven't accumulated any tracked references.  The main     * thread should be starting with a clean slate.     */    if (dvmReferenceTableEntries(&dvmThreadSelf()->internalLocalRefTable) != 0)<span style="white-space:pre"></span>//确保主线程当前不应用JAVA对象，保证一个干净的入口    {        ALOGW("Warning: tracked references remain post-initialization");        dvmDumpReferenceTable(&dvmThreadSelf()->internalLocalRefTable, "MAIN");    }    /* general debugging setup */    if (!dvmDebuggerStartup()) {<span style="white-space:pre"></span>//初始化调试环境        return "dvmDebuggerStartup failed";    }    if (!dvmGcStartupClasses()) {<span style="white-space:pre"></span>// GC class        return "dvmGcStartupClasses failed";    }

初始化各项子模块

    /*     * Init for either zygote mode or non-zygote mode.  The key difference     * is that we don't start any additional threads in Zygote mode.     */    if (gDvm.zygote) {        if (!initZygote()) {            return "initZygote failed";        }    } else {        if (!dvmInitAfterZygote()) {            return "dvmInitAfterZygote failed";        }    }

判断是否在zygote中启动虚拟机，注意是initZygote不是dvmInitZygote

/* * Do zygote-mode-only initialization. */static bool initZygote(){    /* zygote goes into its own process group */    setpgid(0,0);    // See storage config details at http://source.android.com/tech/storage/    // Create private mount namespace shared by all children    if (unshare(CLONE_NEWNS) == -1) {        SLOGE("Failed to unshare(): %s", strerror(errno));        return -1;    }    // Mark rootfs as being a slave so that changes from default    // namespace only flow into our children.    if (mount("rootfs", "/", NULL, (MS_SLAVE | MS_REC), NULL) == -1) {        SLOGE("Failed to mount() rootfs as MS_SLAVE: %s", strerror(errno));        return -1;    }    // Create a staging tmpfs that is shared by our children; they will    // bind mount storage into their respective private namespaces, which    // are isolated from each other.    const char* target_base = getenv("EMULATED_STORAGE_TARGET");    if (target_base != NULL) {        if (mount("tmpfs", target_base, "tmpfs", MS_NOSUID | MS_NODEV,                "uid=0,gid=1028,mode=0050") == -1) {            SLOGE("Failed to mount tmpfs to %s: %s", target_base, strerror(errno));            return -1;        }    }    // Mark /system as NOSUID | NODEV    const char* android_root = getenv("ANDROID_ROOT");    if (android_root == NULL) {        SLOGE("environment variable ANDROID_ROOT does not exist?!?!");        return -1;    }    std::string mountDev(getMountsDevDir(android_root));    if (mountDev.empty()) {        SLOGE("Unable to find mount point for %s", android_root);        return -1;    }    if (mount(mountDev.c_str(), android_root, "none",            MS_REMOUNT | MS_NOSUID | MS_NODEV | MS_RDONLY | MS_BIND, NULL) == -1) {        SLOGE("Remount of %s failed: %s", android_root, strerror(errno));        return -1;    }#ifdef HAVE_ANDROID_OS    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) {        if (errno == EINVAL) {            SLOGW("PR_SET_NO_NEW_PRIVS failed. "                  "Is your kernel compiled correctly?: %s", strerror(errno));            // Don't return -1 here, since it's expected that not all            // kernels will support this option.        } else {            SLOGW("PR_SET_NO_NEW_PRIVS failed: %s", strerror(errno));            return -1;        }    }#endif    return true;}

注释比较全，主要是父子进程共享资源的问题。

到这里实例的创建和初始化工作就算完成了，dvmStartup函数也算结束了，要注意的是dvmStartup函数反回的是一个字符串。

JNI_CreateJavaVM函数中是这样调用的

    std::string status =            dvmStartup(argc, argv.get(), args->ignoreUnrecognized, (JNIEnv*)pEnv);

    if (!status.empty()) {        free(pEnv);        free(pVM);        ALOGW("CreateJavaVM failed: %s", status.c_str());        return JNI_ERR;    }

返回到AndroidRuntime::start，之后执行的函数是startReg，注册Android核心类的JNI方法

int AndroidRuntime::startReg(JNIEnv* env){    /*     * 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;}

总结：创建实例，处理配置信息 ——> 收集配置信息，创建环境 ——> 切换线程状态，初始化虚拟机实例 ——> 注册核心方法 ——> 启动main方法

最后附上老罗的图