标签： Zygote

Zygote进程—SystemServer的诞生

2021年8月5日
SystemServer, Zygote
Zygote进程—SystemServer的诞生已关闭评论

在ZygoteInit的main（）方法中做了几件大事，其中一件便是启动Systemserver进程，代码如下：

@/frameworks/base/core/Java/com/Android/internal/os/ZygoteInit.java

[java] view plain copy print?

public static void main(String argv[]) {
try {
……
if (argv[1].equals(“start-system-server”)) {
startSystemServer();//启动system_server进程
} else if (!argv[1].equals(“”)) {
throw new RuntimeException(argv[0] + USAGE_STRING);
}
……
}

startSystemServer方法的实现如下：

@/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

[java] view plain copy print?

/**
* Prepare the arguments and fork for the system server process.
*/
private static boolean startSystemServer()
throws MethodAndArgsCaller, RuntimeException {
long capabilities = posixCapabilitiesAsBits(
OsConstants.CAP_KILL,
OsConstants.CAP_NET_ADMIN,
OsConstants.CAP_NET_BIND_SERVICE,
OsConstants.CAP_NET_BROADCAST,
OsConstants.CAP_NET_RAW,
OsConstants.CAP_SYS_MODULE,
OsConstants.CAP_SYS_NICE,
OsConstants.CAP_SYS_RESOURCE,
OsConstants.CAP_SYS_TIME,
OsConstants.CAP_SYS_TTY_CONFIG
);
/* Hardcoded command line to start the system server */
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=” + capabilities + “,” + capabilities,
“–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);
/* Request to fork the system server process */
pid = Zygote.forkSystemServer(//以fork的方式创建system_server进程
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
/* For child process */
if (pid == 0) {//pid==0说明在子进程中，父进程为Zygote
handleSystemServerProcess(parsedArgs);
}
return true;
}

在startSystemServer中先设置了fork SystemServer所需的参数，然后通过forkSystemServer方法fork出SystemServer进程，*后通过handleSystemServerProcess处理新进程中的善后事宜。

首先看一下参数：

1、setuid=1000,这里1000代表SYSTEM_UID，即系统进程，关于进程ID的说明可以参见：/frameworks/base/core/java/android/os/Process.java。

2、nice-name=system_server表示制定进程的名字为“system_server”

3、com.android.server.SystemServer表示SystemServer类的位置。

接下来看一下forkSystemServer的实现：

@/libcore/dalvik/src/main/java/dalvik/system/Zygote.java

[java] view plain copy print?

/**
* Special method to start the system server process. In addition to the
* common actions performed in forkAndSpecialize, the pid of the child
* process is recorded such that the death of the child process will cause
* zygote to exit.
*
* @param uid the UNIX uid that the new process should setuid() to after
* fork()ing and and before spawning any threads.
* @param gid the UNIX gid that the new process should setgid() to after
* fork()ing and and before spawning any threads.
* @param gids null-ok; a list of UNIX gids that the new process should
* setgroups() to after fork and before spawning any threads.
* @param debugFlags bit flags that enable debugging features.
* @param rlimits null-ok an array of rlimit tuples, with the second
* dimension having a length of 3 and representing
* (resource, rlim_cur, rlim_max). These are set via the posix
* setrlimit(2) call.
* @param permittedCapabilities argument for setcap()
* @param effectiveCapabilities argument for setcap()
*
* @return 0 if this is the child, pid of the child
* if this is the parent, or -1 on error.
*/
public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
preFork();
int pid = nativeForkSystemServer(
uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
postFork();
return pid;
}
native public static int nativeForkSystemServer(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);

nativeForkSystemServer*终通过JNI实现，代码为：

@/dalvik/vm/native/dalvik_system_Zygote.cpp

[java] view plain copy print?

/*
* native public static int nativeForkSystemServer(int uid, int gid,
* int[] gids, int debugFlags, int[][] rlimits,
* long permittedCapabilities, long effectiveCapabilities);
*/
static void Dalvik_dalvik_system_Zygote_forkSystemServer(
const u4* args, JValue* pResult)
{
pid_t pid;
pid = forkAndSpecializeCommon(args, true);
/* The zygote process checks whether the child process has died or not. */
if (pid > 0) {//pid大于0，说明是在父进程中
int status;
ALOGI(“System server process %d has been created”, pid);
gDvm.systemServerPid = pid;
/* There is a slight window that the system server process has crashed
* but it went unnoticed because we haven’t published its pid yet. So
* we recheck here just to make sure that all is well.
*/
if (waitpid(pid, &status, WNOHANG) == pid) {//堵塞，等待system_server进程
ALOGE(“System server process %d has died. Restarting Zygote!”, pid);
kill(getpid(), SIGKILL);//一旦上面的等待返回，说明进程pid（system_server）已终止，此时Zygote杀死自己
}
}
RETURN_INT(pid);
}

可以看出Dalvik_dalvik_system_Zygote_forkSystemServer会调用forkAndSpecializeCommon来fork出system_server进程。这里要注意*后几句，在fork出system_server以后，Zygote会调用waitpid等待system_server的终止，一旦发现system_server终止，Zygote则马上自杀。

接下来看一下handleSystemServerProcess的实现：

@/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

[java] view plain copy print?

/**
* Finish remaining work for the newly forked system server process.
*/
private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws ZygoteInit.MethodAndArgsCaller {
closeServerSocket();//关闭从Zygote复制过来的socket
// set umask to 0077 so new files and directories will default to owner-only permissions.
Libcore.os.umask(S_IRWXG | S_IRWXO);//设置文件的默认权限,去除所有者之外的权限
if (parsedArgs.niceName != null) {
Process.setArgV0(parsedArgs.niceName);//system_server
}
if (parsedArgs.invokeWith != null) {
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
null, parsedArgs.remainingArgs);
} else {
/*
* Pass the remaining arguments to SystemServer.
*/
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);
}
/* should never reach here */
}

上面的代码中用到了Linux中的umask这个函数，不明白的读者可以参考：http://hi.baidu.com/fengyun409/item/82cd158ffe7f67c8b17154e7。

下面继续看RuntimeInit.zygoteInit方法的实现：

@/frameworks/base/core/java/com/android/internel/os/RuntimeInit.java

[java] view plain copy print?

/**
* The main function called when started through the zygote process. This
* could be unified with main(), if the native code in nativeFinishInit()
* were rationalized with Zygote startup.<p>
*
* Current recognized args:
* <ul>
* <li> <code> [–] <start class name> <args>
* </ul>
*
* @param targetSdkVersion target SDK version
* @param argv arg strings
*/
public static final void zygoteInit(int targetSdkVersion, String[] argv)
throws ZygoteInit.MethodAndArgsCaller {
if (DEBUG) Slog.d(TAG, “RuntimeInit: Starting application from zygote”);
redirectLogStreams();//将System.out 和 System.err 输出重定向到Android 的Log系统
/*
* 初始化了一些系统属性，其中*重要的一点就是设置了一个未捕捉异常的handler，
* 当代码有任何未知异常，就会执行它，
* 调试过Android代码的同学经常看到的”*** FATAL EXCEPTION IN SYSTEM PROCESS” 打印就出自这里
*/
commonInit();
/*
* *终会调用app_main的onZygoteInit函数
* 这里的作用是在新进程中引入Binder，也就说通过nativeZygoteInit以后，新的进程就可以使用Binder进程通信了
*/
nativeZygoteInit();
applicationInit(targetSdkVersion, argv);//应用初始化
}

这个函数是不是有些面熟？没错在《Zygote进程【2】——Zygote的分裂》一文中我们见过，Zygote进程在接收到ActivityManagerService请求创建进程的请求时就调用的该方法来处理创建子进程的后续工作。

[java] view plain copy print?

private static void applicationInit(int targetSdkVersion, String[] argv)
throws ZygoteInit.MethodAndArgsCaller {
// If the application calls System.exit(), terminate the process
// immediately without running any shutdown hooks. It is not possible to
// shutdown an Android application gracefully. Among other things, the
// Android runtime shutdown hooks close the Binder driver, which can cause
// leftover running threads to crash before the process actually exits.
nativeSetExitWithoutCleanup(true);
// We want to be fairly aggressive about heap utilization, to avoid
// holding on to a lot of memory that isn’t needed.
VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
final Arguments args;
try {
args = new Arguments(argv);
} catch (IllegalArgumentException ex) {
Slog.e(TAG, ex.getMessage());
// let the process exit
return;
}
// Remaining arguments are passed to the start class’s static main
invokeStaticMain(args.startClass, args.startArgs);
}

所以，这里与Zygote分裂时不同的是：这里的args.startClass的值为com.android.server.SystemServer。接下来大家都知道了，SystemServer类的main函数将会被调用。

@/frameworks/base/services/java/com/android/server/SystemServer.java

[java] view plain copy print?

public static void main(String[] args) {
if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
// If a device’s clock is before 1970 (before 0), a lot of
// APIs crash dealing with negative numbers, notably
// java.io.File#setLastModified, so instead we fake it and
// hope that time from cell towers or NTP fixes it
// shortly.
Slog.w(TAG, “System clock is before 1970; setting to 1970.”);
SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);//初始化系统时间
}
if (SamplingProfilerIntegration.isEnabled()) {
SamplingProfilerIntegration.start();
timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
SamplingProfilerIntegration.writeSnapshot(“system_server”, null);
}
}, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
}
// Mmmmmm… more memory!
dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();
// The system server has to run all of the time, so it needs to be
// as efficient as possible with its memory usage.
VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
Environment.setUserRequired(true);
System.loadLibrary(“android_servers”);//加载android_servers库
Slog.i(TAG, “Entered the Android system server!”);
// Initialize native services.
nativeInit();//初始化native service
// This used to be its own separate thread, but now it is
// just the loop we run on the main thread.
ServerThread thr = new ServerThread();
thr.initAndLoop();
}

在main中会加载libandroid_servers.so库，然后调用nativeInit初始化native层的Service。

[java] view plain copy print?

/**
* Called to initialize native system services.
*/
private static native void nativeInit();

@/frameworks/base/services/jni/com_android_server_SystemServer.cpp

[java] view plain copy print?

static void android_server_SystemServer_nativeInit(JNIEnv* env, jobject clazz) {
char propBuf[PROPERTY_VALUE_MAX];
property_get(“system_init.startsensorservice”, propBuf, “1”);
if (strcmp(propBuf, “1”) == 0) {
// Start the sensor service
SensorService::instantiate();
}
}

可以看出这里只初始化了传感器service，这与之前的代码有所不同，在比较早的Android版本中，服务的初始化分为init1和init2两个过程，其中init主要负责native层service的初始化（SurfaceFlinger、AudioFlinger等），init2负责java层service的初始化。

在main方法*后会调用ServerThread类的initAndLoop来初始化系统服务，这个函数比较长，这里就不复制代码了。

好了，到这里SystemServer的诞生过程就完了

Zygote是什么?

2021年8月5日
Zygote
Zygote是什么?已关闭评论

Zygote是什么

操作系统中，进程实际上是文件到地址空间的映射像。进程将要运行时，由操作系统将其映射到地址空间，完成这项工作的事物本质也应是一个进程，我们称这个进程为孵化进程，那么这个进程怎么收到消息创建新的进程呢？可以推测，在操作系统中应当存在一个全局监听创建新进程消息的监听进程，当它收到消息时，通知孵化进程进行孵化。在安卓中，负责孵化新进程的这个进程叫做Zygote，安卓上其他的APK进程都是由它孵化的。

世界的神

众所周知，安卓是Linux内核，安卓系统上运行的一切程序都是放在Dalvik虚拟机上的，Zygote也不例外，事实上，它是安卓运行的*个Dalvik虚拟机进程。既然Zygote负责孵化其他的安卓进程，那么它自己是由谁孵化的呢？这个问题就像上帝创造了世界，那上帝是谁创造的呢？上帝一定是由我们这个世界之外，他自己所在的那个“新世界”的神所创造的。如果把安卓系统看做我们所在的这个世界，那么Zygote所在的那个“新世界”就是Linux内核，Zygote就是由Linux内核的“神”创造的，这个“神”就是Linux内核启动的用户级进程init，关于init这里不再讨论。

亚当和夏娃

上面的比喻将Zygote看做安卓世界的神，事实上，由于操作系统还需要一个监听创建新进程请求的进程，在安卓中，这个进程就是SystemServer，Zygote与负责监听新进程的SystemServer协同合作才能孵化APK进程，所以Zygote更恰当的比喻是亚当。

就像夏娃是由亚当身体里的一根肋骨创造的一样，SystemServer也是由Zygote孵化出来的*个Dalvik虚拟机进程。SystemServer与Zygote都是一个程序在内存中映射的进程，这个程序就是app_process。

造人的过程

由于SystemServer与Zygote分属安卓操作系统中不同Davik虚拟机上运行的不同的进程，在安卓上不同进程之间通信是通过Binder机制来实现的（关于Binder的运行机制浅析在这里）。那么SystemServer与Zygote是不是分别有一个在需要孵化新进程时用于通信的Binder呢？就像亚当与夏娃分别有一个***用于造人。很遗憾的是，SystemServer与Zygote并不是通过Binder来进行通信的，而是利用更为原始的Socket传递消息，在SystemServer中有一个Socket客户端，Zygote中的Socket服务端负责接收孵化请求。

就像亚当和夏娃生出了许多孩子后，可能需要一个保姆来帮他们照顾小孩一样。安卓系统中有那么多运行中的进程，肯定需要有一个管家来帮助他们管理孵化出来的进程，这个管家就是AmS，事实上AmS的主要任务是负责管理Activity，兼职管理安卓系统的内存和运行中的进程。

下面将Zygote与SystemServer联合孵化新进程的大概流程梳理出来：SystemServer中负责管理进程的AmS利用Socket客户端向Zygote的Socket服务端发送创建新进程命令，Zygote收到命令后为APK创建进程ActivityThread，每个APK进程不仅有自己的数据资源和需要执行的代码，还与其他进程分享Android框架中通用的资源和代码，由于这些资源和代码是大部分APK都需要调用到的，并且比较重量级，所以安卓把它们都放在Zygote进程的空间中，当APK需要的时候就直接到里面去找就行了。

流程图如下：

%title插图%num

——参考至《Android内核剖析》

深入理解Android启动过程

2021年6月15日
Android启动, Bootloader, Dalvik, linux内核, Zygote
深入理解Android启动过程已关闭评论

当按下Android设备上的电源键时发生了什么？

Android的启动过程是怎样的？

什么是linux内核？

桌面系统的linux内核和Android系统的linux内核之间有什么不同？

什么是Bootloader？

什么是Zygote？

什么是x86和ARM linux？

什么是init.rc？

什么是系统服务？

当我们在思考Android启动过程的时候，脑海中总是会浮现出这么多的问题。

在这里我将为你解释Android的启动过程，希望能帮助你找到以上这些问题的答案。

Android是一个基于linux内核的开源操作系统，x86（x86是指一系列计算机微处理器指令集架构，这些指令集架构基于intel 8086 CPU）是linux内核部署*常见的系统。然而，所有的Android设备都运行在ARM处理器（ARM（来源于高级精简指令集机器，而这又来源于ARM架构））上，当然，英特尔的Xolo设备（http://xolo.in/xolo-x900-features）除外，Xolo来源于Atom 1.6GHz x86处理器。Android设备（或者嵌入式设备，又或者基于linux的ARM设备）的启动过程与桌面版本相比有一点差别。这篇文章中，我将只解释 Android设备的启动过程。关于基于linux的桌面系统的启动过程，推荐大家阅读Inside the linux boot process这篇文章。

当你按下电源开关后，Android设备执行了以下步骤

%title插图%num

*步：开机和系统启动

当电源按下，引导芯片代码从预定义的地方（固化在ROM）开始执行。加载Bootloader到RAM，然后执行。

第二步：Bootloader

Bootloader是在Android操作系统运行之前运行的一个小程序。Bootloader是运行的*个程序，所以它是针对特定的主板与芯片的。设备制造商要么使用比较流行的的Bootloader，比如redboot、uboot、qi bootloader，要么开发自己的Bootloader，它不属于Android操作系统的部分。Bootloader是OEM厂商或者运营商加锁和限制的地方。

Bootloader分两个阶段执行。*个阶段，检测外部RAM以及加载对第二阶段有用的程序，第二阶段，Bootloader设置网络、内存等等。这些对于运行内核是必要的，为了某些特定的目标，Bootloader可以向内核提供配置参数或者输入数据。

Android的Bootloader可以在<Android Source>\bootable\bootloader\legacy\usbloader目录找到。传统的加载器包含两个重要的文件，需要在这里说明：

1. init.s — 初始化堆栈，清零BBS段，调用main.c中的_main()函数

2. main.c — 初始化硬件（闹钟、主板、键盘、控制台），创建linux标签

要了解更多关于Android Bootloader的知识可以参考这个连接：

https://motorola-global-portal.custhelp.com/app/answers/detail/a_id/86208/~/bootloader-frequently-asked-questions

第三步：内核

Android内核的启动与桌面linux内核启动的方式类似。内核启动时开始设置高速缓存、内存保护机制、调度，加载驱动程序。当内核完成系统设置后，它首先在系统文件中寻找”init”文件，然后启动root进程或者系统的*个进程。

第四步：init进程

init是*个进程，我们可以管它叫root进程或者所有进程的父进程。init进程有两个任务，1. 挂载目录，比如/sys、/dev、/proc。2. 运行init.rc脚本。

· init进程可以在<Android Source>/system/core/init找到

· init.rc文件可以在<Android Source>/system/core/rootdir/init.rc找到

· readme.txt可以在<Android Source>/system/core/init/readme.txt找到

对于init.rc文件，Android中有特定的格式和规则。在Android中，我们称之为Android初始化语言。
Android初始化语言由四大类型的声明组成，分别是：Actions（动作）、Commands（命令）、Services（服务）、以及Options（选项）。
Action（动作）：Action（动作）就是一些命名的命令序列，Action（动作）有一个触发器，用来决定这个Action（动作）何时发生。
语法如下

n <trigger>
<command>
<command>
<command>

Service（服务）：Service（服务）是一些由init进程启动的程序、当这些Service（服务）退出时init进程会根据情况将其重启。

语法如下

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

Options（选项）：Options（选项）是对服务的描述。它们影响init进程如何以及何时启动服务。

让我们看看默认的init.rc文件。这里我只列出了主要的事件以及服务。

Action/Service	描述
on early-init	设置init进程以及它创建的子进程的优先级。为init进程设置安全环境。
on init	设置全局环境为cpu accounting创建cgroup(资源控制)挂载点 ……
on fs	挂载mtd分区
on post-fs	更改系统目录的访问权限
on post-fs-data	更改/data目录及其子目录的访问权限
on boot	基本网络的初始化，内存管理等等
Service servicemanager	启动系统的服务管理器来管理所有的本地服务，比如位置、音频、Shared preference等等
service zygote	启动zygote进程

在这个阶段你就可以在设备的屏幕上看到“Android”logo了。

第五步：Zygote和Dalvik

在Java中，我们知道不同的虚拟机实例会为不同的应用分配不同的内存。假如Android应用应该尽可能快地启动，如果Android系统为每一个应用启动不同的Dalvik虚拟机实例，就会消耗大量的内存和时间。因此，为了克服这个问题，Android系统创造了”Zygote”。Zygote使得Dalvik虚拟机共享代码、低内存占用和*小的启动时间成为可能。Zygote是一个虚拟机进程，正如我们在前一个步骤所说，它在系统启动时启动。 Zygote预加载并且初始化核心类库。通常，这些核心类都是只读的，是Android SDK或者核心框架的一部分。在Java虚拟机中，每一个实例都有它自己的核心库类文件和堆对象的拷贝。

Zygote加载进程

1. 加载ZygoteInit类，源代码：<Android Source>/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

2. registerZygoteSocket() — 为zygote命令连接注册一个服务器套接字

3. preloadClasses()—“preloaded-classes”是一个简单的包含一系列需要预加载类的文本文件，你可以在<Android Source>/frameworks/base找到“preloaded-classes”文件。

4. preloadResources() — preloadResources意味着本地主题和布局以及android.R文件中包含的所有东西都会用这个方法加载。

在这个时候，你可以看到开机动画。

第六步：系统服务或服务

完成了上面几步之后，Runtime请求Zygote启动系统服务。系统服务同时使用native以及java编写，系统服务可以认为是一个进程。同一个系统服务可以以System Services的形式在Android SDK获得。系统服务包含了所有的System Services。

Zygote创建新的进程去启动系统服务。你可以在ZygoteInit类的”startSystemServer”方法中找到源代码。

核心服务：

1. 启动电源管理器

2. 创建Activity管理器

3. 启动电话注册

4. 启动包管理器

5. 设置Activity管理服务为系统进程

6. 启动上下文管理器

7. 启动系统Context Providers

8. 启动电池服务

9. 启动定时管理器

10. 启动传感服务

11. 启动窗口管理器

12. 启动蓝牙服务

13. 启动挂载服务

其他服务：

1. 启动状态栏服务

2. 启动硬件服务

3. 启动网络状态服务

4. 启动连接服务

5. 启动通知管理器

6. 启动设备存储监视服务

7. 启动定位管理器

8. 启动搜索服务

9. 启动剪切板服务

10. 启动登记服务

11. 启动壁纸服务

12. 启动音频服务

13. 启动耳机监听

14. 启动AdbSettingsObserver（处理adb命令）。

第七步：启动完成

一旦系统服务在内存中运行起来，Android就完成了启动过程。在这个时候“ACTION_BOOT_COMPLETED”广播就会发出去。

2024 年 12 月
一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31