Android源码分析--system_server进程分析

在上一篇博文中我们进行了有关Zygote进程的分析，我们知道Zygote进程创建了一个重要的进程–system_server进程后就进入了无限循环中，之后Android系统中的重要任务就交给了system_server进程，作为zygote的嫡长子进程，system_server进程的意义非凡，今天我们来分析一下system_server进程。

创建system_server进程

在ZygoteInit中main方法中，通过调用startSystemServer方法开启了system_server进程。该方法主要为创建system_server进程准备了一些参数，并调用本地方法forkSystemServer创建system_server进程。让我们来看一下startSystemServer方法的代码：

    private static boolean startSystemServer()            throws MethodAndArgsCaller, RuntimeException {        String args[] = {            "--setuid=1000",            "--setgid=1000",            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",            "--capabilities=130104352,130104352",            "--runtime-init",            "--nice-name=system_server",            "com.android.server.SystemServer",        };        ZygoteConnection.Arguments parsedArgs = null;        int pid;        try {            parsedArgs = new ZygoteConnection.Arguments(args);            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);            /* 创建system_server进程 */            pid = Zygote.forkSystemServer(                    parsedArgs.uid, parsedArgs.gid,                    parsedArgs.gids,                    parsedArgs.debugFlags,                    null,                    parsedArgs.permittedCapabilities,                    parsedArgs.effectiveCapabilities);        } catch (IllegalArgumentException ex) {            throw new RuntimeException(ex);        }        /* 子进程中执行 */        if (pid == 0) {            handleSystemServerProcess(parsedArgs);        }        return true;    }

这里的代码并不复杂，可以看到，他调用了forkSystemServer方法来创建一个新的进程，之后在子进程，即system_server进程中执行handleSystemServerProcess方法。下面我们来看一下forkSystemServer方法，它是一个native方法对应的源文件在dalvik\vm\native\dalvik_system_Zygote.cpp中。代码如下：

static void Dalvik_dalvik_system_Zygote_forkSystemServer(        const u4* args, JValue* pResult){    pid_t pid;    pid = forkAndSpecializeCommon(args, true);    /* zygote进程检查其子进程是否死掉 */    if (pid > 0) {        int status;        ALOGI("System server process %d has been created", pid);        gDvm.systemServerPid = pid;        /*  如果system_server进程退出，则zygote进程也会被杀掉 */        if (waitpid(pid, &status, WNOHANG) == pid) {            ALOGE("System server process %d has died. Restarting Zygote!", pid);            kill(getpid(), SIGKILL);        }    }    RETURN_INT(pid);}

从代码中可以看到在forkAndSpecializeCommon方法中，我们创建了子进程，并返回了子进程id，接下来我检查如果system_server进程是否退出，若是的话则zygote进程也将会被被干掉，由此可见其重要性。接下来我们来看forkAndSpecializeCommon的代码，这个system_server进程的创建真的是千峰百转啊。。。

static pid_t forkAndSpecializeCommon(const u4* args, bool isSystemServer){    pid_t pid;    uid_t uid = (uid_t) args[0];    gid_t gid = (gid_t) args[1];    ArrayObject* gids = (ArrayObject *)args[2];    u4 debugFlags = args[3];    ArrayObject *rlimits = (ArrayObject *)args[4];    u4 mountMode = MOUNT_EXTERNAL_NONE;    int64_t permittedCapabilities, effectiveCapabilities;    char *seInfo = NULL;    char *niceName = NULL;    //传入参数isSystemServer为true    if (isSystemServer) {        permittedCapabilities = args[5] | (int64_t) args[6] << 32;        effectiveCapabilities = args[7] | (int64_t) args[8] << 32;    } else {       ......    }    if (!gDvm.zygote) {        dvmThrowIllegalStateException(            "VM instance not started with -Xzygote");        return -1;    }    // 在第一次调用fork函数之前需要调用    if (!dvmGcPreZygoteFork()) {        ALOGE("pre-fork heap failed");        dvmAbort();    }    setSignalHandler();    //向log文件中写入一些数据    dvmDumpLoaderStats("zygote");    //子进程被fork出来    pid = fork();    if (pid == 0) {    //在这里根据传入的参数对子进程做出一些处理，例如设置进程名，设置各种id等    ......    }    return pid;}

至此system_server进程终于被创建出来，我们可以看到system_server进程也是通过Linux系统特有的Fork机制分裂克隆出来的。在fork之前，我们还有一个重要方法没有分析–setSignalHandler方法，该方法用来设置信号处理，下面让我来看一下吧。

static void setSignalHandler(){    int err;    struct sigaction sa;    memset(&sa, 0, sizeof(sa));    sa.sa_handler = sigchldHandler;    err = sigaction (SIGCHLD, &sa, NULL);//设置信号处理函数，该信号是子进程死亡的信号    if (err < 0) {        ALOGW("Error setting SIGCHLD handler: %s", strerror(errno));    }}static void sigchldHandler(int s){    pid_t pid;    int status;    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {        /* 打印出我们所关心的进程的死亡状态. */        ......        /*         * 如果刚刚销毁的进程是system_server, 同时杀死zygote进程         * 这样system_server进程和zygote进程将会被init进程重启         */        if (pid == gDvm.systemServerPid) {            ALOG(LOG_INFO, ZYGOTE_LOG_TAG,                "Exit zygote because system server (%d) has terminated",                (int) pid);            kill(getpid(), SIGKILL);        }    }    if (pid < 0) {        ALOG(LOG_WARN, ZYGOTE_LOG_TAG,            "Zygote SIGCHLD error in waitpid: %s",strerror(errno));    }}

这里我们发现我们之前已经看到在forkSystemServer方法中已经检查过system_server进程是否死亡，为什么这里还要再一次进行检查？这是为了防止在我们还没有得到fork子进程的pid时，system_server进程就已经死亡的情况。

总结一下：system_server进程的创建经历了漫长的历程：首先startSystemServer中调用了native方法forkSystemServer；之后在native方法forkSystemServer中调用了forkAndSpecializeCommon方法；在forkAndSpecializeCommon方法中fork之前还调用了setSignalHandler来设置信号处理项。这样，我们的system_server进程终于被创建起来，同时他还和zygote进程保持着同生共死的关系。

system_server进程的职责

在startSystemServer的方法中我们可以看到，在创建进程之后，在子进程即system_server进程中会执行handleSystemServerProcess方法，这便是system_server的职责所在，下面我们来看一下：

    private static void handleSystemServerProcess(            ZygoteConnection.Arguments parsedArgs)            throws ZygoteInit.MethodAndArgsCaller {        closeServerSocket();        // 设置权限.        Libcore.os.umask(S_IRWXG | S_IRWXO);        ......        if (parsedArgs.invokeWith != null) {        ......        } else {            /* 剩余的参数传递到SystemServer. */            RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);        }    }

可以看到最后system_server进程来到了RuntimeInit中，它的实现在frameworks\base\core\java\com\android\internal\os\RuntimeInit.java中

    public static final void zygoteInit(int targetSdkVersion, String[] argv)            throws ZygoteInit.MethodAndArgsCaller {        if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");        //关闭System.out和System.err，使用Android log        redirectLogStreams();        //做一些常规初始化        commonInit();        //native层初始化,调用此方法之后system_server将与Binder通信系统建立联系，这样就可以使用Binder了        nativeZygoteInit();        applicationInit(targetSdkVersion, argv);    }    private static void applicationInit(int targetSdkVersion, String[] argv)            throws ZygoteInit.MethodAndArgsCaller {        ......        try {            args = new Arguments(argv);        } catch (IllegalArgumentException ex) {            Slog.e(TAG, ex.getMessage());            // let the process exit            return;        }        invokeStaticMain(args.startClass, args.startArgs);    }

可以看到，最终我们调用了invokeStaticMain方法，该方法的传入参数在startSystemServer方法中被设置，其传入参数的类名是”com.android.server.SystemServer”

    private static void invokeStaticMain(String className, String[] argv)            throws ZygoteInit.MethodAndArgsCaller {        Class<?> cl;        try {            cl = Class.forName(className);        } catch (ClassNotFoundException ex) {            throw new RuntimeException(                    "Missing class when invoking static main " + className,                    ex);        }        Method m;        try {            m = cl.getMethod("main", new Class[] { String[].class });        } catch (NoSuchMethodException ex) {            throw new RuntimeException(                    "Missing static main on " + className, ex);        } catch (SecurityException ex) {            throw new RuntimeException(                    "Problem getting static main on " + className, ex);        }        int modifiers = m.getModifiers();        if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {            throw new RuntimeException(                    "Main method is not public and static on " + className);        }        /* 抛出的异常在ZygoteInit.main()中被截获 */        throw new ZygoteInit.MethodAndArgsCaller(m, argv);    }

让我们来看看被截获的语句：

 catch (MethodAndArgsCaller caller) {            caller.run();//调用了caller的run方法        } 

run方法代码：

public void run() {            try {                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);            }        }

可以看到，在函数最后抛出异常，在ZygoteInit.main()中被截获，由于传递的参数类名是”com.android.server.SystemServer”，这样我们调用了MethodAndArgsCaller.run()方法去执行了SystemServer类的静态main方法。（关于ZygoteInit可以参考上一篇博文：Android源码分析–Zygote进程分析）

    public static void main(String[] args) {        ......        // Mmmmmm... more memory!        dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();        // system server一直在运行, 所以他需要尽可能有效的利用内存        VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);        Environment.setUserRequired(true);        System.loadLibrary("android_servers");        Slog.i(TAG, "Entered the Android system server!");        // native方法，进行一些传感器服务的初始化        nativeInit();        // 创建一个单独的线程，在这里启动系统的各项服务        ServerThread thr = new ServerThread();        thr.initAndLoop();    }

最终，system_server开启了一个新的线程，并执行了它的initAndLoop方法，其也被定义在SystemServer.java中，该方法的代码较多，其主要的工作就是开启了系统中的各项服务，如电池服务，蓝牙服务等等。并调用了Looper的prepareMainLooper方法进行消息循环，然后处理消息，这里不再赘述。

最后，我们来总结一下：

• 首先system_server执行handleSystemServerProcess方法来完成自己的使命；
• 之后调用RuntimeInit.zygoteInit方法，在这里我们进行了一些常规的初始化工作已经native层的初始化，从而与Binder通信建立联系；
• 之后调用invokeStaticMain方法，利用抛出异常的方法在ZygoteInit的main方法中截获并去执行SystemServer的main方法；
• 在SystemServer的main方法中，我调用nativeInit方法去初始化一些传感器服务，并开启了单独的线程去开启Android系统中的各项服务，并调用了Looper的prepareMainLooper方法进行消息循环，然后处理消息