深入理解Android(07)——深入理解SystemServer

1、背景知识

SystemServer的进程名实际上叫做“system_server”，这里我们可以将其简称为SS，SS作为zygote的重要分支，是非常重要的一部分。

2、SystemServer诞生

SystemServer诞生，是通过如下代码来的：

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


            /*
             * Enable debugging of the system process if *either* the command line flags
             * indicate it should be debuggable or the ro.debuggable system property
             * is set to "1"
             */
            int debugFlags = parsedArgs.debugFlags;
            if ("1".equals(SystemProperties.get("ro.debuggable")))
                debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER;


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

上面的代码，主要是说SystemServer主要是由Zygote通过Zygote.forkSystemServer函数fork诞生的。

接下来我们看看这个forkSystemServer的实现，它是一个native函数，实现主要再dalvik_system_Zygote.c中，如下所示：dalvik/vm/native/dalvik_system_Zygote.c

/* native public static int forkSystemServer(int uid, int gid,
 *     int[] gids, int debugFlags, long permittedCapabilities,
 *     long effectiveCapabilities);
 */
static void Dalvik_dalvik_system_Zygote_forkSystemServer(
        const u4* args, JValue* pResult)
{
    pid_t pid;
	// 根据参数，fork一个子进程。
    pid = forkAndSpecializeCommon(args, true);


    /* The zygote process checks whether the child process has died or not. */
    if (pid > 0) {
        int status;


        LOGI("System server process %d has been created", pid);
        gDvm.systemServerPid = pid;
        /* 函数退出前须先检查刚创建的子进程是否退出了
         */
        if (waitpid(pid, &status, WNOHANG) == pid) {
		// 如果system_server退出了，Zygote直接干掉了自己
		// 看来Zygote和SS的关系异常紧密，简直是生死与共！
            LOGE("System server process %d has died. Restarting Zygote!", pid);
            kill(getpid(), SIGKILL);
        }
    }
    RETURN_INT(pid);
}

/*
 * Utility routine to fork zygote and specialize the child process.
 */
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];
    int64_t permittedCapabilities, effectiveCapabilities;

    // 设置信号处理
    setSignalHandler();

    dvmDumpLoaderStats("zygote");
	// fork子进程
    pid = fork();

    if (pid == 0) {
        // 根据传入的参数对子进程进行一些处理
		// 最常见的比如，设置进程名，设置各种ID（用户ID，组ID）
    } else if (pid > 0) {
        /* the parent process */
    }

    return pid;
}

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) {
        LOGW("Error setting SIGCHLD handler: %s", strerror(errno));
    }
}

/*
 * This signal handler is for zygote mode, since the zygote
 * must reap its children
 */
static void sigchldHandler(int s)
{
    pid_t pid;
    int status;


    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        }


        /*
         * If the just-crashed process is the system_server, bring down zygote
         * so that it is restarted by init and system server will be restarted
         * from there.
         */
		 // 如果死去的子进程是SS，则Zygote把自己也干掉了，这样就做到了生死与共
        if (pid == gDvm.systemServerPid) {
            LOG(LOG_INFO, ZYGOTE_LOG_TAG,
                "Exit zygote because system server (%d) has terminated\n",
                (int) pid);
            kill(getpid(), SIGKILL);
        }
    }


    if (pid < 0) {
        LOG(LOG_WARN, ZYGOTE_LOG_TAG,
            "Zygote SIGCHLD error in waitpid: %s\n",strerror(errno));
    }
}

3、SystemServer用来干嘛

SS诞生了之后，便和Zygote分道扬镳了，它有了自己的使命。代码如下：

       

 /* Request to fork the system server process */
        pid = Zygote.forkSystemServer(
                parsedArgs.uid, parsedArgs.gid,
                 parsedArgs.gids, debugFlags, null,
                parsedArgs.permittedCapabilities,
                parsedArgs.effectiveCapabilities);
	        /* For child process */
	        if (pid == 0) {
	            handleSystemServerProcess(parsedArgs);
	        }

/**
     * Finish remaining work for the newly forked system server process.
     */
    private static void handleSystemServerProcess(
            ZygoteConnection.Arguments parsedArgs)
            throws ZygoteInit.MethodAndArgsCaller {


		// 关闭从Zygote那里继承下来的Socket
        closeServerSocket();


        /*
         * Pass the remaining arguments to SystemServer.
         * "--nice-name=system_server com.android.server.SystemServer"
         */
		// 调用ZygoteInit函数
        RuntimeInit.zygoteInit(parsedArgs.remainingArgs);
        /* should never reach here */
    }


    public static final void zygoteInit(String[] argv)
            throws ZygoteInit.MethodAndArgsCaller {
        // 做一些常规的初始化
        commonInit();
		// native层的初始化
        zygoteInitNative();


        int curArg = 0;
        for ( /* curArg */ ; curArg < argv.length; curArg++) {
            String arg = argv[curArg];


            if (arg.equals("--")) {
                curArg++;
                break;
            } else if (!arg.startsWith("--")) {
                break;
            } else if (arg.startsWith("--nice-name=")) {
                String niceName = arg.substring(arg.indexOf('=') + 1);
				// 设置进程名为niceName，也就是“system_server”
                Process.setArgV0(niceName);
            }
        }


		// startClass名为“com.android.server.SystemServer”
        String startClass = argv[curArg++];
        String[] startArgs = new String[argv.length - curArg];


        System.arraycopy(argv, curArg, startArgs, 0, startArgs.length);
		// 调用startClass，也就是com.android.server.SystemServer类的main函数
        invokeStaticMain(startClass, startArgs);
    }

3、真实的SystemServer

ZygoteInit分裂产生的SS，其实就是为了调用com.android.server.SystemServer的main函数，代码如下：

framework/base/services/java/com/android/server/SystemServer.java

    public static void main(String[] args) {
        // 加载libandroid_servers.so
        System.loadLibrary("android_servers");
		// 调用native的init1函数
        init1(args);
    }

4、SystemServer的总结

SS的整个进程图示，可以用以下的一副图示进行简单说明，如下：