1.1 Android系统启动流程(Zygote进程)

Android启动模式

  • recovery升级模式:启动recovery分区内核和文件系统
  • 正常启动模式:引导内核和启动Android系统
    1. 启动电源以及系统启动:加载引导程序Bootloader到RAM
    2. Bootloader :主要启动系统OS
    3. Linux Kenel :启动内核,设置缓存、被保护存储器、计划列表,加载驱动;查找init文件,启动init进程
    4. init进程启动 : init进程PID是1,父进程为linux系统内核的0号进程;初始化和启动属性服务,并且启动Zygote进程
    5. Zygote进程启动 : 创建DVM虚拟机并注册JNI,创建服务端Socket,启动SystemSrver进程
    6. SystemServer进程启动 : 启动Binder线程池和SystemServiceManager,并启动各种系统服务
    7. Launcher启动 在SystemServer进程中启动ActivityManagerService服务后启动Launcher,桌面程序启动后显示已安装应用的快捷图标

一. Android init进程

init进程执行程序所在位置/init,其源代码所在目录system/core/init;作为用户空间的第一个进程,被赋予了很多及其重要的工作职责,比如创建zygote(孵化器)和属性服务等。

init进程主要工作内容

  • 第一个应用程序
  • 创建目录,并挂载设备
  • 解析启动脚本(init.rc脚本),触发Action及启动Service(例如启动zygote进程)
  • 提供系统property服务管理及完成对应的触发事件
  • 维护系统及Service

init.rc

init.rc是一个配置文件,内部有Android初始化语言编写的脚本。在Android7.0中对init.rc进行了拆分,每个服务对应一个rc文件。Android重要的zygote服务的启动脚本则在init.zygoteXX.rc中定义,例如64位处理器则是init.zygote64.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 /dev/stune/foreground/tasks

通知init进程创建zygote的service进程,程序路径为/system/bin/app_process64,启动的class name 是main。

在init进程中,通过解析init.rc资源文件,fork()一个子线程并启动zygote线程。

二. Zygote进程

在Android系统中,DVM(Dalvik虚拟机)、应用程序进程以及运行系统的关键服务的SystemServer进程都是由Zygote进程通过fork(复制进程)创建的。Zygote进程在启动时会创建DVM,因此fork而来的进程应用程序进程和SystemServer进程都可以在内部获取到一个DVM实例拷贝。

Zygote启动流程

  1. zygote进程是由app_process程序执行后更改名称而来,在frameworks/base/cmds/app_process/app_main.cpp中调用AppRuntime.start()启动Java层的ZygoteInit
int main(int argc, char* const argv[])
{
    //...
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    //...
     Vector args;
    if (!className.isEmpty()) {
        //非zygote模式,
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className, argc - i, argv + i);
    } else {
        // zygote模式下,初始化设置一些参数供后面的zygote使用
        maybeCreateDalvikCache();
        if (startSystemServer) {
            args.add(String8("start-system-server"));//1
        }
        //...
    }
    if (!niceName.isEmpty()) {
        //修改进程名称,将app_process改为zygote
        runtime.setArgv0(niceName.string());
        set_process_name(niceName.string());
    }
    if (zygote) {
        //zygote模式下调用ZygoteInit
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
       //...
    }
}
  1. AppRuntime继承了AndroidRuntime,runtime.start实际调用了AndroidRuntime.start()方法。
void AndroidRuntime::start(const char* className, const Vector& options, bool zygote)
{
    //...
    //初始化JNI
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    //创建DVM虚拟机
    if (startVm(&mJavaVM, &env, zygote) != 0) { 
        return;
    }
    onVmCreated(env);
    //注册JNI
    if (startReg(env) < 0) { 
        ALOGE("Unable to register all android natives\n");
        return;
    }
    //通过反射机制调用com.android.internal.os.ZygoteInit的main函数
    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);
    //从app_main的main函数得知className为com.android.internal.os.ZygoteInit
    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);
    }
    char* slashClassName = toSlashClassName(className);
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
    //找到ZygoteInit的main函数
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");//3
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
        //通过JNI调用ZygoteInit的main函数
            env->CallStaticVoidMethod(startClass, startMeth, strArray);//4
#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
  ...
}
  1. Zygote进程启动Java框架层,执行ZygoteInit
//com.android.internal.os.ZygoteInit

public static void main(String argv[]) {
        ZygoteServer zygoteServer = new ZygoteServer();
        ZygoteHooks.startZygoteNoThreadCreation();
        //...
        try {
            //...
            boolean startSystemServer = false;
            String socketName = "zygote";
            String abiList = null;
            boolean enableLazyPreload = false;
            //读取argv[]参数
            //...

            //1.注册zygote服务使用的socket,zygote与其他进程通信使用了socket方式,而不是Binder.
            zygoteServer.registerServerSocket(socketName);

            if (!enableLazyPreload) {
                //2.记载类以及各种资源
                preload(bootTimingsTraceLog);
       
            } else {
                Zygote.resetNicePriority();
            }

            //...

            //3.创建系统服务SystemServer进程,启动一些系统核心程序
            if (startSystemServer) {
                startSystemServer(abiList, socketName, zygoteServer);
            }

            //4.监听客户端请求,并调用相应的函数进行处理
            zygoteServer.runSelectLoop(abiList);

            zygoteServer.closeServerSocket();
        } catch (Zygote.MethodAndArgsCaller caller) {
            caller.run();
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            zygoteServer.closeServerSocket();
            throw ex;
        }
    }

  1. zygoteServer.registerServerSocket()创建LocalServerSocket,也就是服务端的Socket。待Zygote进程将SystemServer进程启动后,
//com.android.internal.os.ZygoteServer

void registerServerSocket(String socketName) {
        if (mServerSocket == null) {
            int fileDesc;
            final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
            try {
                String env = System.getenv(fullSocketName);
                fileDesc = Integer.parseInt(env);
            } catch (RuntimeException ex) {
                throw new RuntimeException(fullSocketName + " unset or invalid", ex);
            }

            try {
                FileDescriptor fd = new FileDescriptor();
                fd.setInt$(fileDesc);
                mServerSocket = new LocalServerSocket(fd);
            } catch (IOException ex) {
                throw new RuntimeException(
                        "Error binding to local socket '" + fileDesc + "'", ex);
            }
        }
    }

  1. 通过Zygote.forkSystemServer方式创建SystemServer进程;handleSystemServerProcess(parsedArgs)调用ZygoteInit.zygoteInit()来进行native层的初始化,并通过jnvokeStaticMain()反射方式调用com.android.server.SystemServer.main方法
//com.android.internal.os.ZygoteInit
private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        //...
        String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
            "--capabilities=" + capabilities + "," + capabilities,
            "--nice-name=system_server",
            "--runtime-args",
            "com.android.server.SystemServer",
        };
        ZygoteConnection.Arguments parsedArgs = null;

        int pid;

        try {
            parsedArgs = new ZygoteConnection.Arguments(args);
            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

            /* Request to fork the system server process */
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        /* For child process */
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }
            zygoteServer.closeServerSocket();
            
            handleSystemServerProcess(parsedArgs);
        }

        return true;
    }

//com.android.server.SystemServer

public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
    try {
        //初始化一些系统属性参数

        //配置虚拟机的一些参数等等之类工作

 
        android.os.Process.setThreadPriority(
            android.os.Process.THREAD_PRIORITY_FOREGROUND);
        android.os.Process.setCanSelfBackground(false);
        Looper.prepareMainLooper();

        // 初始化Native层android_servers
        System.loadLibrary("android_servers");

        // Check whether we failed to shut down last time we tried.
        // This call may not return.
        performPendingShutdown();

        // 创建系统层级的Context上下文
        createSystemContext();

        // 创建初始化SystemServiceManager
        mSystemServiceManager = new SystemServiceManager(mSystemContext);
        mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
       
        SystemServerInitThreadPool.get();
    } finally {
        traceEnd();  
    }

    // 初始化启动Framework层的Services
    try {
        traceBeginAndSlog("StartServices");
        startBootstrapServices();
        startCoreServices();
        startOtherServices();
        SystemServerInitThreadPool.shutdown();
    } catch (Throwable ex) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    } finally {
        traceEnd();
    }

    //...

    // 消息轮训
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

  1. runSelectLoop()监听客户端请求(例如ActivityManagerService发送请求,经过一些列的调用最终调用Process.zygoteSendArgsAndGetResult()方法),ServerSocket监听处理请求,在ZygoteConnection.run()方法中fork一个子进程并由子进程来处理。
//com.android.internal.os.ZygoteInit

void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
        //....
        while (true) {
            //....
            for (int i = pollFds.length - 1; i >= 0; --i) {
                //...
                if (i == 0) {
                    //获取Socket连接
                    ZygoteConnection newPeer = acceptCommandPeer(abiList);
                    peers.add(newPeer);
                    fds.add(newPeer.getFileDesciptor());
                } else {
                    //对每个连接调用runOnce处理
                    boolean done = peers.get(i).runOnce(this);
                    if (done) {
                        peers.remove(i);
                        fds.remove(i);
                    }
                }
            }
        }
    }

//com.android.internal.os.ZygoteConnection

boolean runOnce(ZygoteServer zygoteServer) throws Zygote.MethodAndArgsCaller {
        //...
            //fork出一个子进程
            pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                    parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                    parsedArgs.niceName, fdsToClose, fdsToIgnore, parsedArgs.instructionSet,
                    parsedArgs.appDataDir);
        

      
            if (pid == 0) {
               
                zygoteServer.closeServerSocket();
                //...
                //子进程处理函数
                handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
                //...
                }
        //...
    }

Zygote进程总结

1.1 Android系统启动流程(Zygote进程)_第1张图片
流程图
  • main方法中创建AppRuntime并调用其start方法
  • 在runtime.start方法中创建DVM虚拟机,并未DVM注册JNI
  • 通过JNI反射方式调用ZygoteInit的mian函数进入Zygote的Java框架层
  • 通过registerZygoteSocket函数创建服务端的Socket,并通过runSelectLoop函数等待ActivityManagerService等请求来fork新的应用程序进程
  • fork启动SystemServer进程

你可能感兴趣的:(1.1 Android系统启动流程(Zygote进程))