要点
流程
Init进程启动过程
init进程是Android系统中用户空间的第一个进程,进程号pid为1,是Android系统启动流程中一个关键的步骤,作为第一个进程,它被赋予了很多极其重要的工作职责,比如创建Zygote(孵化器)和属性服务等。
Init进程开启前几步流程
在Init进程开启前还有几步流程的,这里我们先来了解下Android系统启动流程的前几步。如下,当我们按下启动电源时,系统启动后会加载引导程序,引导程序又启动Linux 内核,在Linux 内核加载完成后,第一件事就是要启动init 进程。
- 启动电源以及系统启动:当电源按下时引导芯片代码从预定义的地方(固化在ROM)开始执行。加载引导程序BootLoader到RAM中。
- 引导程序BootLoader:引导程序BootLoader是在Android操作系统开始运行前的一个小程序,它的主要作用是把系统OS拉起来并运行
- Linux内核启动:当内核启动时,设置缓存、被保护存储器、计划列表、加载驱动。在内核完成系统设置后,它首先在系统文件中寻找init.rc文件,并启动init进程
- init进程启动
Init进程做了哪些事?
在Linux内核加载完成后,会启动init进程,同时在系统文件中寻找init.rc文件,init进程的main方法如下(system\core\init.init.cpp 核心代码):
int main(int argc, char** argv) {
//1、创建和挂载启动所需的文件目录,其中挂载了
//tmpfs、devpts、proc、sysfs和selinuxfs共5种文件系统
//这些都是系统运行时目录,只在系统运行时才会存在,系统停止时会消失
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
#define MAKE_STR(x) __STRING(x)
mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
chmod("/proc/cmdline", 0440);
gid_t groups[] = { AID_READPROC };
setgroups(arraysize(groups), groups);
mount("sysfs", "/sys", "sysfs", 0, NULL);
mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL);
mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));
//2、对属性服务进行初始化
property_init();
//3、用于设置子进程信号处理函数,系统会在子进程暂停、终止时发出SIGCHLD信号
//而signal_handler_init()函数就是用来接收SIGCHLD信号的(其内部只处理SIGCHLD信号)
//,如收到子进程终止信号,方法内部会层层处理,最终找到子进程并移除子进程的所有信息。
//再在6处重新开启进程。
//这个信号处理主要为了防止init进程的子进程成为僵尸进程。
//在UNIX/Linux中,父进程使用fork创建子进程,在子进程终止之后,
//如果父进程并不知道子进程已经终止了,这时子进程虽然已经退出了,
//但是在系统进程表中还为它保留了一定的信息(比如进程号、退出状态、运行时间等),
//这个子进程就被称作僵尸进程。系统进程表是一项有限资源,如果系统进程表被僵尸
//进程耗尽的话,系统就可能无法创建新的进程了。
signal_handler_init();
//4、启动属性服务
//Windows 平台上有一个注册表管理器,Android也提供了一个类似的机制,叫作属性服务.
//注册表管理器记录用户、软件的一些使用信息。即使系统或者软件重启,其还是能够根据
//之前注册表中的记录,进行相应的初始化工作
//其实属性服务就是一个Socket 能够同时处理多个用户(client)请求
start_property_service();
//5、解析init.rc 配置文件
parser.ParseConfig("/init.rc");
//6、重启死去的进程
restart_processes();
}
init.rc 文件简介
init.rc文件中配置了一些init要开启的进程,这些进程在init 进程中创建如zygote进程、serviceManager进程、surfaceFligner进程、mediaServer进程。
init进程启动总结,总的来说主要做了以下三件事
- 创建和挂载启动所需的文件目录。
- 初始化和启动属性服务。
- 解析init.rc配置文件并启动Zygote进程。
Zygote进程启动过程
在Android系统中,DVM和ART、应用程序进程以及运行系统的关键服务的SystemServer进程都是由Zygote进程来创建的,我们也将它称为孵化器。它通过fock(复制进程)的形式来创建应用程序进程和SystemServer进程,由于Zygote进程在启动时会创建DVM或者ART,因此通过fock而创建的应用程序进程和SystemServer进程可以在内部获取一个DVM或者ART的实例副本。
Zygote进程是在init进程启动时创建的,起初Zygote进程的名称并不是叫“zygote”,而是叫“app_process”,这个名称是在Android.mk中定义的,Zygote进程启动后,Linux系统下的pctrl系统会调用app_process,将其名称换成了“zygote”。
Zygote进程的启动过程
Android 8.0对init.rc文件进行了拆分,每个服务对应一个rc文件。在init.rc中通过安卓初始化语言import 语句来引入Zygote 的rc文件。然后通过ServiceParse类的parseSection、parseLineSection进行解析rc文件中的Service语句,得到可执行程序路径,运行可执行程序,启动Zygote进程。init启动Zygote时主要是调用app_main.cpp的main函数中的AppRuntime的start方法来启动Zygote进程的。
#init.rc
import /init.${ro.zygote}.rc // 根据{ro.zygote}的值动态加载对应的Zygote.rc文件
#init.zygote32.rc
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
class main
priority -20
user root
group root readproc
socket zygote stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver //audioserver进程终止了就重启进程
onrestart restart cameraserver//进程终止了就重启进程
onrestart restart media//进程终止了就重启进程
onrestart restart netd
onrestart restart wificond
writepid /dev/cpuset/foreground/tasks
/*
如上脚本:
1、zygote 要开启的进程名
2、app_process 要执行程序名,位置在/system/bin/路径下
3、main classname
4、如果audioserver、cameraserver、media等进程终止了,就需要进行restart(重启)
*/
#frameworks\base\cmds\app_process\app_main.cpp
int main(int argc, char* const argv[]){
/*
Zygote 进程都是通过fock 自身来创建子进程的,
这样Zygote 进程以及它的子进程都可以进入app_main.cpp的main函数,
因此main函数中为了区分当前运行在哪个进程,进行如下判断。
*/
while (i < argc) {
const char* arg = argv[i++];
//如果当前运行在Zygote进程中则将zygote设置为true
if (strcmp(arg, "--zygote") == 0) {
zygote = true;
niceName = ZYGOTE_NICE_NAME;
//如果当前运行在SystemServer进程中则处将startSystemServer 设置为true
} else if (strcmp(arg, "--start-system-server") == 0) {
startSystemServer = true;
} else if (strcmp(arg, "--application") == 0) {
application = true;
} else if (strncmp(arg, "--nice-name=", 12) == 0) {
niceName.setTo(arg + 12);
} else if (strncmp(arg, "--", 2) != 0) {
className.setTo(arg);
break;
} else {
--i;
break;
}
}
...
if (zygote) {//如果为zygote进程则调用Runtime的start方法。
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) {
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
fprintf(stderr, "Error: no class name or --zygote supplied.\n");
app_usage();
LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
}
}
#frameworks\base\core\jni\AndroidRuntime.cpp
//开启JVM
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
if (startVm(&mJavaVM, &env, zygote) != 0) {
return;
}
//为jvm注册jni方法
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
jstring classNameStr;
// 从app_main.cppde的main方法可知className为com.android.internal.os.ZygoteInit
classNameStr = env->NewStringUTF(className);
// 找到ZygoteInit 类
char* slashClassName = toSlashClassName(className);
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
} else {// 找到ZygoteInit 类的main方法。
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
} else {
// 通过jni调用ZygoteInit的main 方法。
env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);
#endif
}
}
/*
这里为何要使用JNI呢?因为ZygoteInit的main方法是由Java语言编写的,
当前的运行逻辑在Native中,这就需要通过JNI来调用Java。这样Zygote
就从Native层进入了Java框架层。
在我们通过JNI调用ZygoteInit的main方法后,Zygote便进入了Java框架层,
此前是没有任何代码进入Java框架层的,换句话说是Zygote开创了Java框架层
*/
#ZygoteInit&main
public static void main(String argv[]) {
...
try {
...
//1. 创建一个 Server 端的 Socket,socketName 为 zygote
//Zygote进程将SystemServer进程启动后,就会在这个服务器端
//的Socket上等待AMS请求Zygote进程来创建新的应用程序进程。
zygoteServer.registerServerSocketFromEnv(socketName);
if (!enableLazyPreload) {
bootTimingsTraceLog.traceBegin("ZygotePreload");
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
//2. 预加载资源和类
preload(bootTimingsTraceLog);
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
SystemClock.uptimeMillis());
bootTimingsTraceLog.traceEnd();
} else {
Zygote.resetNicePriority();
}
...
if (startSystemServer) {
//3. 启动 SystemServer 进程,system_server;启动的类名为
//com.android.server.SystemServer
//系统的服务会由SystemServer进程启动起来
Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
//4. 等待 AMS 请求
//调用ZygoteServer的runSelectLoop方法来等待AMS请求创建新的应用程序进程
//AMS请求成功时会通过ZygoteConnection的runOnce函数来创建一个新的应用程
//序进程
caller = zygoteServer.runSelectLoop(abiList);
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
zygoteServer.closeServerSocket();
}
}
Zygote进程启动总结:Zygote进程启动共主要如下几件事
- 创建AppRuntime并调用其start方法,启动Zygote进程。
- 创建Java虚拟机并为Java虚拟机注册JNI方法。
- 通过JNI调用ZygoteInit的main函数进入Zygote的Java框架层。
- 通过registerZygoteSocket方法创建服务器端Socket,并通过runSelectLoop方法等待AMS的请求来创建新的应用程序进程。
- 启动SystemServer进程。
SystemSever的处理过程
Zygote进程启动了SystemServer进程。具体是在ZygoteInit.java的startSystemServer方法中启动了SystemServer进程。SystemServer进程主要用于创建系统服务,我们熟知的AMS、WMS和PMS都是由它来创建的。
#ZygoteInit.java
//当前进程运行在SystemSever进程中
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
//SystemServer 进程复制了Zygote进程的地址空间,因此也会得到Zygote进程创建
//的Socket,这个Socket对于SystemServer进程没有用处,因此,需要注释1处的代
//码来关闭该Socket
zygoteServer.closeServerSocket();
//启动SystemSever进程
handleSystemServerProcess(parsedArgs);
}
private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws Zygote.MethodAndArgsCaller {
ClassLoader cl = null;
if (systemServerClasspath != null) {
//创建PathClassLoader
cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);
Thread.currentThread().setContextClassLoader(cl);
}
//调用了ZygoteInit的zygoteInit方法作用:
//1、启动Binder线程池。
//2、进入SystemServer的main方法
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
public static final void zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
if (RuntimeInit.DEBUG) {
Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
RuntimeInit.redirectLogStreams();
RuntimeInit.commonInit();
//启动Binder线程池:
//这样SystemServer进程就可以使用Binder与其
//他进程进行通信了。具体是调用nativeZygoteInit 这个native方法最终
//是app_main.cpp中AndroidRuntime的子类AppRuntime的onZygoteInit
//方法开启。
ZygoteInit.nativeZygoteInit();
//进入SystemServer的main方法
//内部通过反射调用找到SystemServer类,调用类的main方法。
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
}
#SystemSever.java
...
//创建Looper
Looper.prepareMainLooper();
// 加载动态库libandroid_sever.so
System.loadLibrary("android_servers");
// Check whether we failed to shut down last time we tried.
// This call may not return.
performPendingShutdown();
// 创建系统context
createSystemContext();
//创建SystemServiceManager,它会对系统服务进行创建、启动和生命周期管理
mSystemServiceManager = new SystemServiceManager(mSystemContext);
traceBeginAndSlog("StartServices");
//分批启动系统服务,这些服务的父类均为SystemService.
startBootstrapServices();//启动引导服务:用SystemServiceManager启动了ActivityManagerService、PowerManagerService、PackageManagerService等服务
startCoreServices();//启动核心服务:启动了DropBoxManagerService、BatteryService、UsageStatsService和WebViewUpdateService
startOtherServices();//启动其他服务:启动了CameraService、AlarmManagerService、VrManagerService等服务
SystemServerInitThreadPool.shutdown();
SystemServer进程被创建后,主要做了如下工作:
- 启动Binder线程池,这样就可以与其他进程进行通信。
- 创建SystemServiceManager,其用于对系统的服务进行创建、启动和生命周期管理
- 启动各种系统服务。
Launcher 启动过程
系统启动的最后一步是启动一个app用来显示系统中已经安装的应用程序,这个应用程序就叫作Launcher。
Launcher app 启动时会使用系统的PackageManagerService,获得系统中已经安装的应用程序的信息,并将这些信息封装成一个快捷图标列表显示在系统屏幕上。用户点击这些快捷图标时就启动相应的应用程序。
Launcher的启动过程
我们知道Zygote进程的主要作用就是孵化应用进程,Zygote进程启动后有一步要做的就是开启一个Socket等待AMS请求创建应用进程。
SystemServer进程在启动的过程中会启动ASM,PackageManagerService,等各种服务。ASM会请求Zygote进程中的Socket,请求创建启动Launcher进程。PackageManagerService启动后会将系统中的应用程序安装完成。这样launcher就可以查询PMS中的应用信息,显示在桌面上啦!
Launcher的主要总用小结
- 作为Android系统的启动器,用于启动应用程序。
- 作为Android系统的桌面,用于显示和管理应用程序的快捷图标或者其他桌面组件。
Android系统启动流程总结
Android系统启动流程主要有以下几个部分:
1.启动电源以及系统启动
当电源按下时引导芯片代码从预定义的地方(固化在ROM)开始执行。加载引导程序BootLoader到RAM,然后执行。
2.引导程序BootLoader
引导程序BootLoader是在Android操作系统开始运行前的一个小程序,它的主要作用是把系统OS拉起来并运行。
3.Linux内核启动
当内核启动时,设置缓存、被保护存储器、计划列表、加载驱动。当内核完成系统设置时,它首先在系统文件中寻找init.rc文件,并启动init进程。
4.init进程启动
初始化和启动属性服务,解析rc文件启动Zygote进程。
5.Zygote进程启动
创建Java虚拟机并为Java虚拟机注册JNI方法,创建服务器端Socket等待AMS请求,启动SystemServer进程。
6.SystemServer进程启动
启动Binder线程池和SystemServiceManager,并且启动各种系统服务。
7.Launcher启动
被SystemServer进程启动的AMS会启动Launcher,Launcher启动后会将已安装应用的快捷图标显示到界面上。
The end
参考
安卓进阶解密:微信读书版