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方法进行消息循环，然后处理消息