Android开机启动流程分析一(Zygote进程)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    ....
    //构造出解析文件用的parser（解析器）对象
    Parser& parser = Parser::GetInstance();
    //为一些类型的关键字，创建特定的parser
    parser.AddSectionParser("service",std::make_unique<ServiceParser>());
    parser.AddSectionParser("on", std::make_unique<ActionParser>());
    parser.AddSectionParser("import", std::make_unique<ImportParser>());
    //开始解析init.rc文件
    //init.rc文件是在init进程启动后执行的启动脚本，文件中记录着init进程需执行的操作。
    //在Android系统中，使用init.rc和init.{ hardware }.rc两个文件。
    //init.rc文件在Android系统运行过程中用于通用的环境设置与进程相关的定义
    //init.{hardware}.rc（例如，高通有init.qcom.rc，MTK有init.mediatek.rc）
    //用于定义Android在不同平台下的特定进程和环境设置等。
    //此处加载的init.rc文件是system/core/rootdir/init.rc，此处记载放在下方解析
    parser.ParseConfig("/init.rc");
    
    ....

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
#if defined(__LP64__)
static const char ABI_LIST_PROPERTY[] = "ro.product.cpu.abilist64";
static const char ZYGOTE_NICE_NAME[] = "zygote64";
#else
static const char ABI_LIST_PROPERTY[] = "ro.product.cpu.abilist32";
static const char ZYGOTE_NICE_NAME[] = "zygote";
#endif

//传入的参数根据上方分析得知有
//{-Xzygote , /system/bin , --zygote , --start-system-server , --socket-name=zygote}
// argc = 5
// argv[] = "-Xzygote /system/bin --zygote --start-system-server --socket-name=zygote";
int main(int argc, char* const argv[])
{
    //下方有AppRuntime和 computeArgBlockSize的代码
    //computeArgBlockSize方法会计算并且返回了传入参数的字节数
    //之后会创建有AppRuntime对象runtime
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    // 进程命令行参数
    // 忽略 argv[0] 即-Xzygote
    argc--;
    argv++;

    // '--'开头或者第一个字符非'-'参数开头的所有内容都将进入vm。
    // 虚拟机参数后的第一个参数是“父目录”，即/system/bin，目前还未使用。
    // 在父目录之后，需要一个或多个内部参数:
    // --zygote : zygote 模式启动
    // --start-system-server : 启动系统服务
    // --application : 开始应用(独立，非Zygote)模式。
    // --nice-name : 进程名
    // 对于非Zygote模式开始，这些参数后面将跟着启动类名。所有剩余的参数都传递给这个类的main方法。
    // 对于zygote模式开始，所有剩余参数都传递给zygote main函数。
    int i;
    for (i = 0; i < argc; i++) {
        if (argv[i][0] != '-') {
            // argv[0] = “/system/bin”，所以直接就结束循环
            break;
        }
        if (argv[i][1] == '-' && argv[i][2] == 0) {
            ++i; // Skip --.
            break;
        }
        //这里过滤后 这部分只有'-'开头的参数
        runtime.addOption(strdup(argv[i]));
    }

    // 解析运行时参数。在第一次未被识别的选项时停止。
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    String8 niceName;
    String8 className;
    // 跳过未使用的“父目录（/system/bin）”参数，所以这里需要解析的参数数组为
    // {--zygote , --start-system-server , --socket-name=zygote}
    ++i;  
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {//是否存在--zygote参数
            //设置zygot参数为true，代表启动zygote模式
            zygote = true;
            niceName = ZYGOTE_NICE_NAME; //将niceName设置为"zygote"或者"zygote64"
        } else if (strcmp(arg, "--start-system-server") == 0) {
            //启动zygot模式存在--start-system-server，将startSystemServer设置为true
            startSystemServer = true; 
        } else if (strcmp(arg, "--application") == 0) {//启动zygote模式不存在--application
            application = true;
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {//启动zygot模式不存在--nice-name
            niceName.setTo(arg + 12);
        } else if (strncmp(arg, "--", 2) != 0) {//启动zygot模式时不会进入
            className.setTo(arg);
            break;
        } else {
            --i;
            break;
        }
    }
  // 启动zygote时，上面运行完对应参数如下:
  // zygote = true; niceName = ZYGOTE_NICE_NAME;startSystemServer = true; 
  // application = false; className =null;i=3;
  Vector<String8> args;//该参数接下来要传入AndroidRuntime.start函数
    if (!className.isEmpty()) { //启动zygote时不会进入
        // 假如我们要启动的不是zygote进程，而是application或tool程序
        // 我们需要传递给RuntimeInit的唯一参数是应用程序参数。
        // 其余的参数传递给启动类的main()。在使用进程名覆盖它们之前，对它们进行复制。
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className, argc - i, argv + i);
    } else {
        //启动zygote时
        maybeCreateDalvikCache();//创建/data/dalvik-cache路径,下方会放源码

        if (startSystemServer) {
            // 设置启动系统服务的参数
            args.add(String8("start-system-server"));
        }

        char prop[PROP_VALUE_MAX];
        // 获取到对应的ABI类型
        // [ro.product.cpu.abilist] : [arm64-v8a, armeabi-v7a, armeabi]
        // [ro.product.cpu.abilist32] : [armeabi-v7a, armeabi]
        // [ro.product.cpu.abilist64] : [arm64-v8a]
        // 根据我们的参数这里获得的是arm64-v8a
        if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
            LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
                ABI_LIST_PROPERTY);
            return 11;
        }
        
        String8 abiFlag("--abi-list=");
        abiFlag.append(prop);
        args.add(abiFlag);

        // 将所有剩余参数添加到args
        // 启动zygote时这里argv就剩下“--socket-name=zygote”参数没加入了，添加进args
        for (; i < argc; ++i) {
            args.add(String8(argv[i]));
        }
    }   
    // 继续启动zygote，此时的args的值为
    //{"start-system-server","--abi-list=ro.product.cpu.abilist64",--socket-name=zygote}

    if (!niceName.isEmpty()) { //启动zygote时不成立
        runtime.setArgv0(niceName.string());
        set_process_name(niceName.string());
    }
    if (zygote) { // 启动zygot时成立，调用
        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();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
        return 10;
    }
}

/************ 下面是内部调用的一些方法的源码，有需要可以看看 ************/
//这里计算并且返回了传入参数的字节数，这样的目的可以确保传入的四个参数是在一个连续的内存中。
static size_t computeArgBlockSize(int argc, char* const argv[]) {
    uintptr_t start = reinterpret_cast<uintptr_t>(argv[0]);
    uintptr_t end = reinterpret_cast<uintptr_t>(argv[argc - 1]);
    end += strlen(argv[argc - 1]) + 1;
    return (end - start);
}

//创建了/data/dalvik-cache目录，并修改该路径的用户、用户组和权限信息
static void maybeCreateDalvikCache() {
#if defined(__aarch64__)
    static const char kInstructionSet[] = "arm64";
#elif defined(__x86_64__)
    static const char kInstructionSet[] = "x86_64";
#elif defined(__arm__)
    static const char kInstructionSet[] = "arm";
#elif defined(__i386__)
    static const char kInstructionSet[] = "x86";
#elif defined (__mips__) && !defined(__LP64__)
    static const char kInstructionSet[] = "mips";
#elif defined (__mips__) && defined(__LP64__)
    static const char kInstructionSet[] = "mips64";
#else
#error "Unknown instruction set"
#endif
    const char* androidRoot = getenv("ANDROID_DATA");//这里的androidRoot为"data
    LOG_ALWAYS_FATAL_IF(androidRoot == NULL, "ANDROID_DATA environment variable unset");

    char dalvikCacheDir[PATH_MAX];
    const int numChars = snprintf(dalvikCacheDir, PATH_MAX,
            "%s/dalvik-cache/%s", androidRoot, kInstructionSet);
    LOG_ALWAYS_FATAL_IF((numChars >= PATH_MAX || numChars < 0),
            "Error constructing dalvik cache : %s", strerror(errno));

    //0711 只有属主有读、写、执行权限；而属组用户和其他用户只有执行权限。 
    int result = mkdir(dalvikCacheDir, 0711); //创建/data/dalvik-cache目录
    LOG_ALWAYS_FATAL_IF((result < 0 && errno != EEXIST),
            "Error creating cache dir %s : %s", dalvikCacheDir, strerror(errno));
    
    //更改/data/dalvik-cache目录的用户与用户组为root用户、root用户组
    result = chown(dalvikCacheDir, AID_ROOT, AID_ROOT);
    LOG_ALWAYS_FATAL_IF((result < 0), "Error changing dalvik-cache ownership : %s", strerror(errno));

    result = chmod(dalvikCacheDir, 0711);//更改/data/dalvik-cache路径的权限
    LOG_ALWAYS_FATAL_IF((result < 0),
            "Error changing dalvik-cache permissions : %s", strerror(errno));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class AppRuntime : public AndroidRuntime
{
public:
    AppRuntime(char* argBlockStart, const size_t argBlockLength)
        : AndroidRuntime(argBlockStart, argBlockLength)
        , mClass(NULL)
    {
    }
    ....
}
/** frameworks/base/core/jni/AndroidRuntime.cpp **/
//静态全局变量gCurRuntime指向AndroidRuntime对象本身,之后我们若需要获取AndroidRuntime对象，获取gCurRuntime就可以了。
static AndroidRuntime* gCurRuntime = NULL;
//创建AndroidRuntime对象
AndroidRuntime::AndroidRuntime(char* argBlockStart, const size_t argBlockLength) :
        mExitWithoutCleanup(false),
        mArgBlockStart(argBlockStart),
        mArgBlockLength(argBlockLength)
{   
    SkGraphics::Init();
    // 预先分配足够的空间来容纳相当数量的选项。
    mOptions.setCapacity(20);
    
    assert(gCurRuntime == NULL);        // one per process
    gCurRuntime = this;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
/*
 * 启动 Android runtime.这部分涉及到启动虚拟机并在名为“className”的类中调用其
 * “static void main(String[] args)”方法。
 * 向main函数传递两个参数，类名和指定的选项字符串。
 */
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    //此时的options为{"start-system-server","--abi-list=ro.product.cpu.abilist64",--socket-name=zygote}
    static const String8 startSystemServer("start-system-server");

    ....
    const char* rootDir = getenv("ANDROID_ROOT");//rootDir为"/system"目录
    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);
    }
    
    /* 启动虚拟机 */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);
    /*
     * 注册安卓jni函数。
     */
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

    /*
     * 创建一个带有参数的数组来保存类名和选项字符串参数
     */
    jclass stringClass;
    jobjectArray strArray;
    jstring classNameStr;

    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
    // String数组
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    assert(strArray != NULL);
    // 即ZygoteInit类名字符串
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    // 将类名传入String数组strArray的第0个位置
    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);
    }

    /*
     * 启动虚拟机。该线程成为VM的主线程，并且在VM退出之前不会返回。
     */
    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");//获取ZygoteInit类的main函数
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
            //调用ZygoteInit.main函数
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
            
#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
    //释放slashClassName
    free(slashClassName);

    ALOGD("Shutting down VM\n");
    if (mJavaVM->DetachCurrentThread() != JNI_OK)
        ALOGW("Warning: unable to detach main thread\n");
    if (mJavaVM->DestroyJavaVM() != 0)
        ALOGW("Warning: VM did not shut down cleanly\n");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/*
 * 启动Dalvik虚拟机。
 *
 * 传入的各种参数(大多数由系统属性决定)。还有一些由“mOptions” Vector更新。
 *
 * 成功返回0
 */
int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote)
{
    ....

    bool checkJni = false;
     //JNI检测功能，用于native层调用jni函数时进行常规检测，比较弱字符串格式是否符合要求，资源是否正确释放。
     //该功能一般用于早期系统调试或手机Eng版，对于User版往往不会开启，引用该功能比较消耗系统CPU资源，降低系统性能。
    property_get("dalvik.vm.checkjni", propBuf, "");
    if (strcmp(propBuf, "true") == 0) {
        checkJni = true;
    } else if (strcmp(propBuf, "false") != 0) {
        /* 判断kernel层是否开启 */
        property_get("pa.kernel.android.checkjni", propBuf, "");
        if (propBuf[0] == '1') {
            checkJni = true;
        }
    }
    ALOGD("CheckJNI is %s\n", checkJni ? "ON" : "OFF");
    if (checkJni) {
        /* 开启JNI检测功能 */
        addOption("-Xcheck:jni");
    }
    //dalvik虚拟机启动模式
    property_get("dalvik.vm.execution-mode", propBuf, "");
    if (strcmp(propBuf, "int:portable") == 0) {
        executionMode = kEMIntPortable;
    } else if (strcmp(propBuf, "int:fast") == 0) {
        executionMode = kEMIntFast;
    } else if (strcmp(propBuf, "int:jit") == 0) {
        executionMode = kEMJitCompiler;
    }
    //虚拟机产生的trace文件，主要用于分析系统问题，路径默认为/data/anr/traces.txt
    parseRuntimeOption("dalvik.vm.stack-trace-file", stackTraceFileBuf, "-Xstacktracefile:");
    
    ....

    /*
     * 堆的默认启动和最大大小。根据不同的设备可以做相应的调整
     */
    //dalvik.vm.heapstartsize:应用程序启动后为其分配的初始大小
    parseRuntimeOption("dalvik.vm.heapstartsize", heapstartsizeOptsBuf, "-Xms", "4m");
    //dalvik.vm.heapsize:单个虚拟机可分配的最大内存
    parseRuntimeOption("dalvik.vm.heapsize", heapsizeOptsBuf, "-Xmx", "16m");
    //dalvik.vm.heapgrowthlimit:每个应用程序最大可分配内存
    parseRuntimeOption("dalvik.vm.heapgrowthlimit", heapgrowthlimitOptsBuf, "-XX:HeapGrowthLimit=");
    //dalvik.vm.heapminfree：堆最小空闲内存
    parseRuntimeOption("dalvik.vm.heapminfree", heapminfreeOptsBuf, "-XX:HeapMinFree=");
    //dalvik.vm.heapmaxfree：堆最大空闲内存
    parseRuntimeOption("dalvik.vm.heapmaxfree", heapmaxfreeOptsBuf, "-XX:HeapMaxFree=");
    //dalvik.vm.heaptargetutilization：堆利用率
    parseRuntimeOption("dalvik.vm.heaptargetutilization",
                       heaptargetutilizationOptsBuf,
                       "-XX:HeapTargetUtilization=");
    //heapminfree、heapmaxfree、heaptargetutilization这三个值的设置则对垃圾回收（GC）的某些性能有影响。

    /*
     * JIT编译器相关配置。JIT：即时编译技术
     */
    ....

    //确保有一个预加载的类文件preloaded-classes(由WritePreloadedClassFile.java生成)。
    //在ZygoteInit类中会预加载工作将其中的classes提前加载到内存，以提高系统性能
    if (!hasFile("/system/etc/preloaded-classes")) {
        ALOGE("Missing preloaded-classes file, /system/etc/preloaded-classes not found: %s\n",
              strerror(errno));
        return -1;
    }
    ....

    //创建虚拟机
    if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
        ALOGE("JNI_CreateJavaVM failed\n");
        return -1;
    }

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/*
 * 向VM注册android jni函数。
 */
/*static*/ int AndroidRuntime::startReg(JNIEnv* env)
{
    ATRACE_NAME("RegisterAndroidNatives");
    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);
    
    //调用register_jni_procs进行jni接口注册,gRegJNI就是通过REG_JNI宏定义的jni函数数组
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    env->PopLocalFrame(NULL);

    return 0;
}

static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
{
    for (size_t i = 0; i < count; i++) {
        if (array[i].mProc(env) < 0) {
#ifndef NDEBUG
            ALOGD("----------!!! %s failed to load\n", array[i].mName);
#endif
            return -1;
        }
    }
    return 0;
}
//REG_JNI宏定义
#define REG_JNI(name)      { name }
    struct RegJNIRec {
        int (*mProc)(JNIEnv*);
    };
    
static const RegJNIRec gRegJNI[] = {
    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),
    REG_JNI(register_android_content_AssetManager),
    REG_JNI(register_android_content_StringBlock),
    REG_JNI(register_android_content_XmlBlock),
    REG_JNI(register_android_text_AndroidCharacter),
    REG_JNI(register_android_text_StaticLayout),
    REG_JNI(register_android_text_AndroidBidi),
    REG_JNI(register_android_view_InputDevice),
    ....
    }