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));
}
}
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的整个进程图示,可以用以下的一副图示进行简单说明,如下: