深入浅出Android系统启动流程

最新推荐文章于 2024-08-13 19:14:05 发布
最新推荐文章于 2024-08-13 19:14:05 发布
阅读量2.2w 收藏 1
点赞数 1
分类专栏： Android Android开发笔记 文章标签： init进程 SystemServer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hai_qing_xu_kong/article/details/85707697
版权

转载请标明出处:【顾林海的博客】
本篇文章已授权微信公众号 顾林海 独家发布

init进程启动过程
init进程概述

       Android系统基于Linux，init进程是Android系统中用户空间的第一个进程，进程号为1，init源代码在system/core/init目录下。既然init进程是Android系统用户空间的第一个进程，因此担负着非常重要的责任，主要负责以下两件事：

  1. 解析配置init.rc，然后启动系统各种native进程，比如Zygote进程、SurfaceFlinger进程以及media进程等。
  2. 初始化并启动属性服务。

在init进程启动前还需要几个步骤：

  1. 启动电源以及系统启动：当电源按下时引导芯片代码从预定义的地方（固化在ROM）开始执行。加载引导程序BootLoader到RAM中，然后执行。
  2. 引导程序BootLoader：引导程序BootLoader是在Android操作系统开始运行前的一个小程序，它的主要作用是把系统OS拉起来并运行。
  3. Linux内核启动：当内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。在内核完成系统设置后，它首先在系统文件中寻找init.rc文件，并启动init进程。
init进程的入口函数

init的入口函数是main，代码如下所示：

//路径：/system/core/init/init.cpp
int main(int argc, char** argv) {
    //注释1
    if (!strcmp(basename(argv[0]), "ueventd")) {
        return ueventd_main(argc, argv);
    }
    //注释2
    if (!strcmp(basename(argv[0]), "watchdogd")) {
        return watchdogd_main(argc, argv);
    }
    //注释3
    if (REBOOT_BOOTLOADER_ON_PANIC) {
        install_reboot_signal_handlers();
    }
    
    ...
}

       注释1处判断当前进程是不是ueventd。init进程创建子进程ueventd，并将创建设备节点文件的工作托付给ueventd。ueventd主要是负责设备节点的创建、权限设定等一系列工作。服务通过使用uevent，监控驱动发送的消息，做进一步处理。

ueventd通过两种方式创建设备节点文件。

  1. “冷插拔”（Cold Plug），即以预先定义的设备信息为基础，当ueventd启动后，统一创建设备节点文件。这一类设备节点文件也被称为静态节点文件。
  2. “热插拔”（Hot Plug），即在系统运行中，当有设备插入USB端口时，ueventd就会接收到这一事件，为插入的设备动态创建设备节点文件。这一类设备节点文件也被称为动态节点文件。

       注释2处判断当前进程是不是watchdogd。Android系统在长时间的运行下会面临各种软硬件的问题，为了解决这个问题，Android开发了WatchDog类作为软件看门狗来监控SystemServer中的线程，一旦发现问题，WatchDog会杀死SystemServer进程，SystemServer的父进程Zygote接收到SystemServer的死亡信号后，会杀死自己。Zygote进程死亡的信号传递到init进程后，init进程会杀死Zygote进程所有的子进程并重启Zygote。

       注释3处判断是否紧急重启，如果是紧急重启，就安装对应的消息处理器。

//路径：/system/core/init/init.cpp
int main(int argc, char** argv) {
    ...
    //注释1
    add_environment("PATH", _PATH_DEFPATH);
    //注释2
    bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr);

    if (is_first_stage) {
        // 用于记录启动时间
        boot_clock::time_point start_time = boot_clock::now();
        // 清除屏蔽字(file mode creation mask)，保证新建的目录的访问权限不受屏蔽字影响
        umask(0);
        // 挂载tmpfs文件系统
        mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
        mkdir("/dev/pts", 0755);
        mkdir("/dev/socket", 0755);
        // 挂载devpts文件系统
        mount("devpts", "/dev/pts", "devpts", 0, NULL);
        #define MAKE_STR(x) __STRING(x)
        // 挂载proc文件系统
        mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
        //8.0新增, 收紧了cmdline目录的权限
        chmod("/proc/cmdline", 0440);
        // 8.0新增，增加了个用户组
        gid_t groups[] = { AID_READPROC };
        setgroups(arraysize(groups), groups);
        // 挂载sysfs文件系统
        mount("sysfs", "/sys", "sysfs", 0, NULL);
        // 8.0新增
        mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL)
        // 提前创建了kmsg设备节点文件，用于输出log信息
        mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
        mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
        mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));
        ...
    }
    ...
}

       注释1处添加环境变量。注释2处获取本次启动是否是系统启动的第一阶段，如果是第一阶段，进入下面的if语句中，创建并挂载相关的文件系统。

以上创建并挂载的五类文件系统分别如下所示：

  • tmpfs：一种虚拟内存文件系统，它会将所有的文件存储在虚拟内存中，如果你将tmpfs文件系统卸载后，那么其下的所有的内容将不复存在。tmpfs既可以使用RAM，也可以使用交换分区，会根据你的实际需要而改变大小。tmpfs的速度非常惊人，毕竟它是驻留在RAM中的，即使用了交换分区，性能仍然非常卓越。由于tmpfs是驻留在RAM的，因此它的内容是不持久的。断电后，tmpfs的内容就消失了，这也是被称作tmpfs的根本原因。

  • devpts：为伪终端提供了一个标准接口，它的标准挂接点是/dev/ pts。只要pty的主复合设备/dev/ptmx被打开，就会在/dev/pts下动态的创建一个新的pty设备文件。

  • proc：一个非常重要的虚拟文件系统，它可以看作是内核内部数据结构的接口，通过它我们可以获得系统的信息，同时也能够在运行时修改特定的内核参数。

  • sysfs：与proc文件系统类似，也是一个不占有任何磁盘空间的虚拟文件系统。它通常被挂接在/sys目录下。sysfs文件系统是Linux2.6内核引入的，它把连接在系统上的设备和总线组织成为一个分级的文件，使得它们可以在用户空间存取。

  • selinuxfs：用于支持SELinux的文件系统，SELinux提供了一套规则来编写安全策略文件，这套规则被称之为 SELinux Policy 语言。

//路径：/system/core/init/init.cpp
int main(int argc, char** argv) {
    ...
    if (is_first_stage) {
        ...
        //重定向输入输出/内核Log系统
        InitKernelLogging(argv);
        LOG(INFO) << "init first stage started!";
        //挂在一些分区设备
        if (!DoFirstStageMount()) {
            LOG(ERROR) << "Failed to mount required partitions early ...";
            panic();
        }
        //注释1
        SetInitAvbVersionInRecovery();
        //注释2
        selinux_initialize(true);
        ...
    }
    ...
}

       注释1处初始化安全框架AVB（Android Verified Boot），AVB主要用于防止系统文件本身被篡改，还包含了防止系统回滚的功能，以免有人试图回滚系统并利用以前的漏洞。注释2处调用selinux_initialize启动SELinux。

//路径：/system/core/init/init.cpp
int main(int argc, char** argv) {
    ...
    if (is_first_stage) {
        ...
    }
    ...
    //注释1
    property_init();  
    ...
    //注释2
    signal_handler_init();
    ...
    //注释3
    start_property_service();
    ...
}

       注释1处通过property_init函数对属性服务进行初始化，注释3通过start_property_service函数启动属性服务。注释2处signal_handler_init设置子进程退出的信号处理函数，当子进程异常退出的时候，init进程会去捕获异常信息，当它捕获到这些异常信息之后，就会调用该函数设置的相应的捕获函数来处理。比如init进程的子进程Zygote死之后，init进程捕获到这些异常信息，就会调用handle_signal()函数去重启Zygote进程。

//路径：/system/core/init/init.cpp
int main(int argc, char** argv) {
    ...
    if (is_first_stage) {
        ...
    }
    ...
     if (bootscript.empty()) {
        //注释1
        parser.ParseConfig("/init.rc");
        ...
    } else {
        ...
    }
    ...
    while (true) {
        ...
        ServiceManager::GetInstance().IsWaitingForExec())) {
            //注释2
            am.ExecuteOneCommand();
        }
        if (!(waiting_for_prop || ServiceManager::GetInstance().IsWaitingForExec())) {
            //注释3
            restart_processes();
            ...
        }
        ...
    }    
    return 0;
}

       注释1处解析init.rc配置文件，在注释2处执行子进程对应的命令，也就是执行init.rc文件里配置的命令。在注释3处重启死掉的service。

解析init.rc

       在init.rc中使用的语言称为Android Init Language，翻译过来就是“Android初始化语言”，init语言共有五种类型的表达式，分别如下所示：

  • Action：Action中包含了一系列的Command。
  • Command：init语言中的命令。
  • Service：由init进程启动的服务。
  • Option：对服务的配置选项。
  • Import：引入其他配置文件。

Action表达式的语法如下所示：

on <trigger> [&& <trigger>]*
    <command>
    <command>
    <command>

       这里的trigger是Action执行的触发器，当触发器条件满足时，command会被执行。触发器有如下两类：

  • 事件触发器：当指定的事件发生时触发。事件可能由“trigger”命令发出，也可能是init进程通过QueueEventTrigger()函数发出。
  • 属性触发器：当指定的属性满足某个值时触发。

Action中的Command是init语言定义的命令，所有支持的命令如下表：

命令参数格式说明
bootchart_init-启动bootchart
chmodoctal-mode path改变文件的访问权限
chownowner group path改变文件的拥有者和组
class_startserviceclass启动指定类别的服务
class_stopserviceclass停止并“disable”指定类别的服务
class_resetserviceclass停止指定类别的服务，但是不“disable”它们
copysrc dst复制文件
domainnamename设置域名
enableservicenameenable一个被disable的服务
exec[seclabel[user[group]]] – command [argument]*fork一个子进程来执行指定的命令
exportname value导出环境变量
hostnamename设置host名称
ifupiterface使网卡在线
insmodpath安装指定路径的模块
load_all_props-从/system、/vendor等路径载入属性
load_persist_props-载入持久化的属性
loglevellevel设置内核的日志级别
mkdirpath[mode][owner][group]创建目录
mount_allfstab[path]*[–option]挂载文件系统并且导入指定的.rc文件
mounttypedevicedir[flag]*[options]挂载一个文件系统
powerctl-内部实现使用
restartservice重启服务
restoreconpath[path]*设定文件的安全上下文
restorecon_recursivepath[path]*restorecon的递归版本
rmpath对于指定路径调用unlink(2)
rmdirpath删除文件夹
setpropnamevalue设置属性值
setrlimitresourcecurmax指定资源的rlimit
startservice启动服务
stopservice停止服务
swapon_allfstab在指定文件上调用fs_mgr_swapon_all
symlinktargetpath创建符合链接
sysclktzmins_west_of_gmt指定系统时钟基准
triggerevent触发一个事件
umountpathummount指定的文件系统
verity_load_state-内部实现使用
verity_update_statemount_point内部实现使用
waitpath[timeout]等待某个文件存在直到超时，若存在则直接返回
writepathcontent写入内容到指定文件

Service是init进程启动的可执行程序，Service表达式的语法如下所示:

service <name> <pathname> [ <argument> ]*
    <option>
    <option>

Option是对服务的修饰，它们影响着init进程如何以及何时启动服务。所有支持的Option入下所示：

Option参数格式说明
critical-标识为系统关键服务，该服务若退出多次将导致系统重启到recovery模式
disabled-不会随着类别自动启动，必须明确start
setenvname value为启动的进程设置环境变量
socketnametypeperm[user[group[seclabel]]]创建UNIX Domain Socket
userusername在执行服务之前切换用户
groupgroupname[groupname]*在执行服务之前切换组
seclabelseclabel在执行服务之前切换seclabel
oneshot-一次性服务，死亡后不用重启
classname指定服务的类别
onrestart-当服务重启时执行命令
writepidfile…写入子进程的pid到指定文件

import是一个关键字，而不是一个命令，可以在.rc文件中通过这个关键字来加载其他的.rc文件，它的语法如下：

import path

path可以是另一个.rc文件，也可以是一个文件夹。如果是文件夹，那么这个文件夹下面的所有文件都会被导入，但是它不会循环加载子目录中的文件。

启动Zygote

init.rc文件有如下配置代码：

...
import /init.${ro.zygote}.rc
...
on nonencrypted
    class_start main
    class_start late_start
...

在init.rc文件的开头使用了import类型语句来引入Zygote启动脚本，其中ro.zygote根据不同的内容引入不同的文件，从Android 5.0开始，Android开始支持64位程序，Zygote就有了32位和64位之分，如下图所示：

在这里插入图片描述

查看init.zygote64.rc的代码如下所示：

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc
    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
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks

       Service用于通知init进程创建名为zygote的进程，这个进程执行程序的路径为/system/bin/app_process64，后面的代码是传递给app_process64的参数，class main指的是Zygote的classname为main。在解析Service类型语句时会将Service对象加入Service链表中。

再回过头看init.rc配置文件：

...
import /init.${ro.zygote}.rc
...
on nonencrypted
    class_start main
    class_start late_start
...

       class_start是一个command，对应的函数是do_class_start，用于启动classname为main的Service，也就是前面的Zygote，因此class_start main是用来启动Zygote的，do_class_start函数在builtins.cpp中定义，代码如下所示：

//路径：/system/core/init/builtins.cpp
static int do_class_start(const std::vector<std::string>& args) {
        /* Starting a class does not start services
         * which are explicitly disabled.  They must
         * be started individually.
         */
    ServiceManager::GetInstance().
        ForEachServiceInClass(args[1], [] (Service* s) { s->StartIfNotDisabled(); });
    return 0;
}

ForEachServiceInClass函数会遍历Service链表，找到classname为main的Zygote，并执行StartIfNotDisabled函数，代码如下所示：

//路径：/system/core/init/service.cpp
bool Service::StartIfNotDisabled() {
    if (!(flags_ & SVC_DISABLED)) {
        return Start();
    } else {
        flags_ |= SVC_DISABLED_START;
    }
    return true;
}

如果Service没有在其对应的rc文件中设置disabled选项，就会调用Start函数，Start函数如下所示：

//路径：/system/core/init/service.cpp
bool Service::Start() {
    ...
    pid_t pid = -1;
    if (namespace_flags_) {
        pid = clone(nullptr, nullptr, namespace_flags_ | SIGCHLD, nullptr);
    } else {
        //注释1
        pid = fork();
    }

    if (pid == 0) {
        ...
        //注释2
        if (execve(strs[0], (char**) &strs[0], (char**) ENV) < 0) {
            PLOG(ERROR) << "cannot execve('" << strs[0] << "')";
        }
        ...
    }
    ...
}

       在注释1处通过fork函数创建子进程，并返回pid，如果pid为0说明当前代码逻辑在子线程中运行，接着执行注释2处的execve函数，来启动Service子进程，进入Service的main函数中，如果Service是Zygote，执行程序的路径是/system/bin/app_process64，对应的文件是app_main.cpp，也就是会进入app_main.cpp的main函数中。代码如下所示：

int main(int argc, char* const argv[])
{
    ...
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            //注释1
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) {
            startSystemServer = true;
        } else if (strcmp(arg, "--application") == 0) {
            application = true;
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {
            niceName.setTo(arg + 12);
        } else if (strncmp(arg, "--", 2) != 0) {
            className.setTo(arg);
            break;
        } else {
            --i;
            break;
        }
    }
    ...
    if (zygote) {
        //注释2
        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.");
    }
}

       在注释1处判断执行命令时是否带了–zygote，如果携带了，zygote赋值为true，接在注释2处判断如果zygote为true，就会通过runtime.start启动com.android.internal.os.ZygoteInit。

Zygote进程启动过程

       在Android系统中，所有的应用程序及系统服务SystemServer进程都由Zygote进程通过Linux的for()函数孵化出来的，因此我们称Zygote是孵化器。

在前面知道了init启动Zygote的相关操作在app_main.cpp的main函数中的，代码如下：

int main(int argc, char* const argv[])
{
    ...
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            //注释1
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) {
            startSystemServer = true;
        } else if (strcmp(arg, "--application") == 0) {
            application = true;
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {
            niceName.setTo(arg + 12);
        } else if (strncmp(arg, "--", 2) != 0) {
            className.setTo(arg);
            break;
        } else {
            --i;
            break;
        }
    }
    ...
    if (zygote) {
        //注释2
        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.");
    }
}

main函数中通过前面的if条件判断语句来区分当前运行在哪个进程，如果是Zygote进程，就会在注释1处将zygote赋值为true，同时执行注释2处的runtime的start函数。

Zygote进程孵化子进程是通过自己的资源复制一份，来fork一个新的子进程，也就是说子进程进入这个文件的main函数，因此，这里的main函数被调用并不只是Zygote启动的时候调用。既然子进程启动的时候同样被调用，那么怎么区分是被Zygote进程本身调用的还是它的子进程调用的呢？这里就通过zygote这个变量来区分，如果是Zygote进程本身，变量zygote为true，否则就会进入到下面的else if里，代表子进程启动。

runtime是一个AppRuntime对象，AppRuntime类继承AndroidRuntime类，因此前面调用的是AndroidRuntime的start函数，代码如下所示：

//路径：/frameworks/base/core/jni/AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ...
    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    //启动Java虚拟机
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);

    //注册JNI方法
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

    ...
    //注释1
    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);
    }

    //将className中的“.”替换成“/”
    //注释2
    char* slashClassName = toSlashClassName(className);
    //注释3
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ...
    } else {
        //注释4
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
           ...
        } else {
            //注释5
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
    ...
}

AndroidRuntime的start函数主要做了以下几件事：

  • 通过startVm函数启动Java虚拟机。
  • 通过startReg函数注册JNI方法。
  • 调用com.android.internal.os.ZygoteInit类的main函数。

其中注释1处的传递过来的className值是com.android.internal.os.ZygoteInit，在注释2处将className中的“.”全部替换为“/”，替换后的值是com/android/internal/os/ZygoteInit，在注释3处获取ZygoteInit类，在注释4处获取ZygoteInit的main方法，最后在注释5处通过JNI调用ZygoteInit的main方法，至此我们进入Java框架层。

ZygoteInit类的main方法如下所示：

//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static void main(String argv[]) {
        ZygoteServer zygoteServer = new ZygoteServer();

        ...

        try {
            ...
            //注释1
            zygoteServer.registerServerSocket(socketName);
            
            if (!enableLazyPreload) {
                ...
                //注释2
                preload(bootTimingsTraceLog);
                ...
            } else {
                Zygote.resetNicePriority();
            }

            ...
            //注释3
            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;
        }
    }

ZygoteInit的main方法中，注释1处通过registerServerSocket方法创建一个Zygote的Socket接口用来和AMS通信。查看registerServerSocket方法：

//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
    void registerServerSocket(String socketName) {
        if (mServerSocket == null) {
            ...

            try {
                ...
                //注释1
                mServerSocket = new LocalServerSocket(fd);
            } catch (IOException ex) {
                throw new RuntimeException(
                        "Error binding to local socket '" + fileDesc + "'", ex);
            }
        }
    }

注释1处创建了一个Java层的LocalServerSocket对象ServerSocket，用于等待创建新的应用程序进程请求连接。

ZygoteInit的main方法中，注释2处通过preload方法预加载类和资源，如果系统不预加载类和资源，每次启动一个应用程序都会去加载这些类和资源，那么启动应用程序的时间就会很长。

ZygoteInit的main方法中，注释3处通过startSystemServer方法启动SystemServer进程。查看startSystemServer方法：

//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //注释1
        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);
            ...
            //注释2
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        //注释3
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            zygoteServer.closeServerSocket();
            //注释4
            handleSystemServerProcess(parsedArgs);
        }

        return true;
    }

注释1处args数组保存的是SystemServer的启动参数，最后封装成Arguments对象，在注释2处通过Zygote的forkSystemServer方法创建子进程，该方法内部会调用nativeForkSystemServer这个Native方法，nativeForkSystemServer方法最终通过fork函数创建一个子进程。在注释3处，判断pid是否等于0，如果等于0，说明当前的代码运行在新创建的子进程中，最后通过注释4处的handleSystemServerProcess方法启动SystemServer进程。

ZygoteInit的main方法中，注释4处调用runSlectLoop方法，通过前面创建的Socket接口，进入一个无限循环，等待核心服务ActivityManagerService请求创建新的应用程序进程。查看runSlectLoop方法：

//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
    void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
        ...

        while (true) {
            StructPollfd[] pollFds = new StructPollfd[fds.size()];
            for (int i = 0; i < pollFds.length; ++i) {
                pollFds[i] = new StructPollfd();
                pollFds[i].fd = fds.get(i);
                pollFds[i].events = (short) POLLIN;
            }
            try {
                Os.poll(pollFds, -1);
            } catch (ErrnoException ex) {
                throw new RuntimeException("poll failed", ex);
            }
            for (int i = pollFds.length - 1; i >= 0; --i) {
                if ((pollFds[i].revents & POLLIN) == 0) {
                    continue;
                }
                //注释1处
                if (i == 0) {
                    ZygoteConnection newPeer = acceptCommandPeer(abiList);
                    peers.add(newPeer);
                    fds.add(newPeer.getFileDesciptor());
                } else {
                    boolean done = peers.get(i).runOnce(this);
                    if (done) {
                        peers.remove(i);
                        fds.remove(i);
                    }
                }
            }
        }
    }

在注释1处，如果i==0，说明Zygote的Socket服务还没准备好，接下来通过acceptCommandPeer方法得到ZygoteConnection对象，并添加到Socket连接列表peers中，同时将这个ZygoteConnection的fd添加到fd列表fds中，以便可以接收到AMS发送过来的请求。如果i!=0，说明正在等待客户端来连接服务端的Socket，当AMS向Zygote进程发送一个创建应用程序进程的请求时，就会调用ZygoteConnection的runOnce()函数来创建应用程序进程的请求，成功创建后从Socket连接列表peers和fd列表中清除这个连接。

SystemServer进程

SystemServer进程主要用于创建系统服务，比如AMS、WMS和PMS都是由它来创建的，SystemServer进程与普通的应用程序进程运行在不同的进程里面，应用进程调用的API，很多都是通过Binder机制调用到SystemServer进程中对应的服务上的。

在ZygoteInit的main函数中通过startSystemServer函数来启动SystemServer进程。查看startSystemServer方法：

//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //注释1
        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);
            ...
            //注释2
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        //注释3
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }
            //注释5
            zygoteServer.closeServerSocket();
            //注释4
            handleSystemServerProcess(parsedArgs);
        }

        return true;
    }

这段代码在上面已经介绍过，最后通过handleSystemServerProcess方法启动SystemServer进程，由于SystemServer是Zygote进程fork出来的，SystemServer进程也有一份Socket，但这个Socket对SystemServer进程没有什么用处，因此通过注释5处关闭这个Socket。handleSystemServerProcess方法的代码如下所示：

//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static void handleSystemServerProcess(
            ZygoteConnection.Arguments parsedArgs)
            throws Zygote.MethodAndArgsCaller {

        ...
        if (systemServerClasspath != null) {
            ...
        } else {
            ...
            //注释1
            ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
        }

    }

在注释1处调用了ZygoteInit的zygoteInit方法，代码如下所示：

//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static final void zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
        ...
        //注释1
        ZygoteInit.nativeZygoteInit();
        //注释2
        RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

    private static final native void nativeZygoteInit();

在注释1处调用nativeZygoteInit方法来创建Binder线程池。注释2处调用RuntimeInit的applicationInit方法，代码如下所示：

    //路径：/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
    protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        ...
        invokeStaticMain(args.startClass, args.startArgs, classLoader);
    }

applicationInit方法中调用了invokeStaticMain方法，如下所示：

    //路径：/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
    private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        Class<?> cl;

        try {
            //注释1
            cl = Class.forName(className, true, classLoader);
        } catch (ClassNotFoundException ex) {
            ...
        }

        Method m;
        try {
            //注释2
            m = cl.getMethod("main", new Class[] { String[].class });
        } catch (NoSuchMethodException ex) {
           ...
        } catch (SecurityException ex) {
           ...
        }

        ...
        //注释3
        throw new Zygote.MethodAndArgsCaller(m, argv);
    }

在注释1处通过反射获取SystemServer类，这里的className值是com.android.server.SystemServer，从前面ZygoteInit的startSystemServer方法中可以发现，代码如下所示：

//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //注释1
        String args[] = {
            ...
            "com.android.server.SystemServer",
        };
        ...
        return true;
    }

在传入的参数中可以看到传入的classname是com.android.server.SystemServer。

继续回到invokeStaticMain方法中，在注释2处获取SystemServer的main方法，最后在注释3处抛出一个异常对象Zgote.MethodAndArgsCaller，使用这种方式是为了清理堆栈，这样之后就会让加载SystemServer类的main方法觉得自己是进程的入口。

接下来看ZygoteInit的main函数捕获这个异常：

    //路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static void main(String argv[]) {
        ...
        try{
        } catch (Zygote.MethodAndArgsCaller caller) {
            //注释1
            caller.run();
        } catch (Throwable ex) {
            ...
        }
        ...
    }

注释1处捕获到Zygote.MethodAndArgsCaller异常后，调用它的run方法：

//路径：/frameworks/base/core/java/com/android/internal/os/Zygote.java
 public final class Zygote { 
    ...
    public static class MethodAndArgsCaller extends Exception
            implements Runnable {
        /** method to call */
        private final Method mMethod;

        /** argument array */
        private final String[] mArgs;

        public MethodAndArgsCaller(Method method, String[] args) {
            mMethod = method;
            mArgs = args;
        }

        public void run() {
            try {
                //注释1
                mMethod.invoke(null, new Object[] { mArgs });
            } catch (IllegalAccessException ex) {
                throw new RuntimeException(ex);
            } catch (InvocationTargetException ex) {
                Throwable cause = ex.getCause();
                if (cause instanceof RuntimeException) {
                    throw (RuntimeException) cause;
                } else if (cause instanceof Error) {
                    throw (Error) cause;
                }
                throw new RuntimeException(ex);
            }
        }
    }
}

MethodAndArgsCaller中的成员变量mMethod，这里指的就是SystemServer的main方法，在注释1处通过反射执行SystemServer的main方法。

进入SystemServer的main方法中：

    //路径：/frameworks/base/services/java/com/android/server/SystemServer.java
    public static void main(String[] args) {
        new SystemServer().run();
    }

main方法中调用了SystemServer的run方法：

//路径：/frameworks/base/services/java/com/android/server/SystemServer.java
private void run() {
        try {

            ...
            //创建消息Looper
            Looper.prepareMainLooper();
            //加载动态库libandroid_servers.so
            System.loadLibrary("android_servers");
            ...
            //创建系统的Context
            createSystemContext();
            //创建SystemServiceManager
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
            //保存SystemServiceManager
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
            //创建系统服务用的线程池
            SystemServerInitThreadPool.get();
        } finally {
            traceEnd();  // InitBeforeStartServices
        }

        //开启服务
        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");
    }

       run方法中最重要的就是SystemServerManager，它的作用是用来对系统的服务进行创建、启动和生命周期管理，创建完SystemServerManager对象后，在后面的三个启动服务方法中会通过SystemServerManager来启动服务，startBootstrapServices方法是用于启动引导服务，引导服务包括ActivityManagerService、PowerManagerService、PackageManagerService、DeviceIdentifiersPolicyService等服务；startCoreServices方法用于启动核心服务，核心服务包括DropBoxManagerService、BatteryService、UsageStatsService以及WebViewUpdateService；startOtherServices方法用于启动其他服务，其他服务包括KeyChainSystemService、TelecomLoaderService、CameraService、AlarmManagerService等服务。

在启动其他服务中会通过ActivityManagerService的systemReady方法来启动Launcher。

参考资料：
《Android进阶解密》
《深入浅出Android源代码》
《android init进程分析ueventd》
《Android ueventd浅析》
《ueventd.rc》
《Android7.0 Watchdog机制》
《Android8.1启动篇（一）：深入研究init（源码分析）》

IT界的吉祥物
关注
专栏目录
Android开发\深入浅出Android.pdf
03-16
《深入浅出Android》一书旨在为Android开发者提供全面、深入的指导，涵盖了从入门到高级的各个环节。以下是对该书部分章节所涉及的关键知识点的详细解析： ### 一、入门：初探Android #### 1. Android简介 - **...
深入浅出Android.pdf
03-01
### 深入浅出Android：全面解析与实践 #### Android简介 - **定义**：Android是一种基于Linux内核的开源移动操作系统，由Google公司及其领导下的开放手机联盟（Open Handset Alliance）进行开发和推广。 - **历史...
Android系统的启动流程
litao55555的博客
06-13 499
每个系统都有一个引导文件，由引导文件去运行linux内核，内核程序开始启动的时候会加载各种驱动和数据结构，开始加载android应用层的第一个进程（init进程c代码（system\core\init目录） Init.c），由这个进程加载其它的进程开始启动，本节主讲从内核开始执行Init.c到启动完成锁屏的过程 1. system\core\init\Init.c int main(int...
android启动过程深入解析,Android启动过程深入解析
weixin_31775717的博客
05-25 204
本文由伯乐在线-云海之巅翻译。未经许可，禁止转载！英文出处：kpbird。欢迎加入翻译小组。当按下Android设备电源键时究竟发生了什么？Android的启动过程是怎么样的？什么是Linux内核？桌面系统linux内核与Android系统linux内核有什么区别？什么是引导装载程序？什么是Zygote？什么是X86以及ARM linux？什么是init.rc?什么是系统服务？当我们想到A...
Android系统启动流程简介
最新发布
kk3087961的博客
08-13 872
ActivityManagerService通过Binder机制与ActivityManager进行通信，提供对系统中其它组件的管理和监控功能.从上面可知SystemServer.startBootstrapServices 启动系统Boot级别服务 会启动ams,调用如下：SystemServiceManager.startService(@NonNull final SystemService service) 方法。
android系统启动流程
xHai的博客
12-28 7214
android系统启动流程android系统启动流程分为以下几个部分：1、启动电源以及系统启动2、引导程序BootLoader3、Linux内核启动4、init进程启动5、Zygote进程启动6、SystemServer进程启动7、Launcher启动 android系统启动流程图： android系统启动流程分为以下几个部分： 1、启动电源以及系统启动 当电源按下时，引导芯片代码从预定义的地方（固化在ROM中）开始执行。加载引导程序BootLoader到RAM，然后执行。 2、引导程序BootLoa
全面解析：深入浅出Android系统详解
资源"深入浅出Android.pdf：一本全面介绍Android系统的书籍，旨在帮助读者快速提升对Android的理解。这本书由知名Android开发社区www.eoeandroid.com 推荐，适合初学者入门。 深入浅出Android是针对Android开发者的...
深入浅出Android.doc
07-08
《深入浅出Android》 Android，作为全球最受欢迎的智能手机操作系统之一，它的开发和应用已经深入到各个领域。本文档旨在帮助读者从入门到精通，全面理解Android系统，并掌握其开发技术。 首先，让我们来了解...
Android系统启动流程
飘渺蜉蝣的博客
09-12 1218
1、启动电源以及系统启动 按下电源键，引导芯片代码从预定义地方（固化在Rom）开始执行。加载引导程序BootLoader到Ram中执行 2、引导程序BootLoader Android系统运行前的一个小程序，主要作用：把系统OS拉起来并运行 3、Linux内核启动 内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。内核完成设置后，启动init进程 4、init进程启动 主要进行初始化、启动属性服务、启动Zygote进程 init进程启动所做的事主要有： 1）创建和挂载启动所需的文件目录 2）初始化和启
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值