Android启动模式
- recovery升级模式：启动recovery分区内核和文件系统
- 正常启动模式：引导内核和启动Android系统
- 启动电源以及系统启动：加载引导程序Bootloader到RAM
- Bootloader :主要启动系统OS
- Linux Kenel :启动内核，设置缓存、被保护存储器、计划列表，加载驱动；查找init文件，启动init进程
- init进程启动 : init进程PID是1，父进程为linux系统内核的0号进程;初始化和启动属性服务，并且启动Zygote进程
- Zygote进程启动 : 创建DVM虚拟机并注册JNI，创建服务端Socket，启动SystemSrver进程
- SystemServer进程启动 : 启动Binder线程池和SystemServiceManager,并启动各种系统服务
- Launcher启动 在SystemServer进程中启动ActivityManagerService服务后启动Launcher，桌面程序启动后显示已安装应用的快捷图标
一. Android init进程
init进程执行程序所在位置/init,其源代码所在目录system/core/init;作为用户空间的第一个进程，被赋予了很多及其重要的工作职责，比如创建zygote(孵化器)和属性服务等。
init进程主要工作内容
- 第一个应用程序
- 创建目录，并挂载设备
- 解析启动脚本(init.rc脚本)，触发Action及启动Service(例如启动zygote进程)
- 提供系统property服务管理及完成对应的触发事件
- 维护系统及Service
init.rc
init.rc是一个配置文件，内部有Android初始化语言编写的脚本。在Android7.0中对init.rc进行了拆分，每个服务对应一个rc文件。Android重要的zygote服务的启动脚本则在init.zygoteXX.rc中定义，例如64位处理器则是init.zygote64.rc。
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
class main
socket zygote stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver
onrestart restart media
onrestart restart netd
writepid /dev/cpuset/foreground/tasks /dev/stune/foreground/tasks
通知init进程创建zygote的service进程，程序路径为/system/bin/app_process64,启动的class name 是main。
在init进程中，通过解析
init.rc资源文件，fork()一个子线程并启动zygote线程。
二. Zygote进程
在Android系统中，DVM(Dalvik虚拟机)、应用程序进程以及运行系统的关键服务的SystemServer进程都是由Zygote进程通过fork(复制进程)创建的。Zygote进程在启动时会创建DVM，因此fork而来的进程应用程序进程和SystemServer进程都可以在内部获取到一个DVM实例拷贝。
Zygote启动流程
- zygote进程是由app_process程序执行后更改名称而来,在
frameworks/base/cmds/app_process/app_main.cpp中调用AppRuntime.start()启动Java层的ZygoteInit
int main(int argc, char* const argv[])
{
//...
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
//...
Vector<String8> args;
if (!className.isEmpty()) {
//非zygote模式，
args.add(application ? String8("application") : String8("tool"));
runtime.setClassNameAndArgs(className, argc - i, argv + i);
} else {
// zygote模式下，初始化设置一些参数供后面的zygote使用
maybeCreateDalvikCache();
if (startSystemServer) {
args.add(String8("start-system-server"));//1
}
//...
}
if (!niceName.isEmpty()) {
//修改进程名称，将app_process改为zygote
runtime.setArgv0(niceName.string());
set_process_name(niceName.string());
}
if (zygote) {
//zygote模式下调用ZygoteInit
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) {
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
//...
}
}
- AppRuntime继承了AndroidRuntime,
runtime.start实际调用了AndroidRuntime.start()方法。
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
//...
//初始化JNI
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
//创建DVM虚拟机
if (startVm(&mJavaVM, &env, zygote) != 0) {
return;
}
onVmCreated(env);
//注册JNI
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
//通过反射机制调用com.android.internal.os.ZygoteInit的main函数
jclass stringClass;
jobjectArray strArray;
jstring classNameStr;
stringClass = env->FindClass("java/lang/String");
assert(stringClass != NULL);
strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
assert(strArray != NULL);
//从app_main的main函数得知className为com.android.internal.os.ZygoteInit
classNameStr = env->NewStringUTF(className);
assert(classNameStr != NULL);
env->SetObjectArrayElement(strArray, 0, classNameStr);
for (size_t i = 0; i < options.size(); ++i) {
jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
assert(optionsStr != NULL);
env->SetObjectArrayElement(strArray, i + 1, optionsStr);
}
char* slashClassName = toSlashClassName(className);
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
/* keep going */
} else {
//找到ZygoteInit的main函数
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");//3
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
/* keep going */
} else {
//通过JNI调用ZygoteInit的main函数
env->CallStaticVoidMethod(startClass, startMeth, strArray);//4
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);
#endif
}
}
...
}
- Zygote进程启动Java框架层，执行ZygoteInit
//com.android.internal.os.ZygoteInit
public static void main(String argv[]) {
ZygoteServer zygoteServer = new ZygoteServer();
ZygoteHooks.startZygoteNoThreadCreation();
//...
try {
//...
boolean startSystemServer = false;
String socketName = "zygote";
String abiList = null;
boolean enableLazyPreload = false;
//读取argv[]参数
//...
//1.注册zygote服务使用的socket，zygote与其他进程通信使用了socket方式，而不是Binder.
zygoteServer.registerServerSocket(socketName);
if (!enableLazyPreload) {
//2.记载类以及各种资源
preload(bootTimingsTraceLog);
} else {
Zygote.resetNicePriority();
}
//...
//3.创建系统服务SystemServer进程，启动一些系统核心程序
if (startSystemServer) {
startSystemServer(abiList, socketName, zygoteServer);
}
//4.监听客户端请求，并调用相应的函数进行处理
zygoteServer.runSelectLoop(abiList);
zygoteServer.closeServerSocket();
} catch (Zygote.MethodAndArgsCaller caller) {
caller.run();
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}
}
-
zygoteServer.registerServerSocket()创建LocalServerSocket,也就是服务端的Socket。待Zygote进程将SystemServer进程启动后，
//com.android.internal.os.ZygoteServer
void registerServerSocket(String socketName) {
if (mServerSocket == null) {
int fileDesc;
final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
try {
String env = System.getenv(fullSocketName);
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
throw new RuntimeException(fullSocketName + " unset or invalid", ex);
}
try {
FileDescriptor fd = new FileDescriptor();
fd.setInt$(fileDesc);
mServerSocket = new LocalServerSocket(fd);
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket '" + fileDesc + "'", ex);
}
}
}
- 通过
Zygote.forkSystemServer方式创建SystemServer进程；handleSystemServerProcess(parsedArgs)调用ZygoteInit.zygoteInit()来进行native层的初始化，并通过jnvokeStaticMain()反射方式调用com.android.server.SystemServer.main方法
//com.android.internal.os.ZygoteInit
private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
throws Zygote.MethodAndArgsCaller, RuntimeException {
//...
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"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(
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) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
zygoteServer.closeServerSocket();
handleSystemServerProcess(parsedArgs);
}
return true;
}
//com.android.server.SystemServer
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
try {
//初始化一些系统属性参数
//配置虚拟机的一些参数等等之类工作
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND);
android.os.Process.setCanSelfBackground(false);
Looper.prepareMainLooper();
// 初始化Native层android_servers
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);
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
SystemServerInitThreadPool.get();
} finally {
traceEnd();
}
// 初始化启动Framework层的Services
try {
traceBeginAndSlog("StartServices");
startBootstrapServices();
startCoreServices();
startOtherServices();
SystemServerInitThreadPool.shutdown();
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
traceEnd();
}
//...
// 消息轮训
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
-
runSelectLoop()监听客户端请求(例如ActivityManagerService发送请求，经过一些列的调用最终调用Process.zygoteSendArgsAndGetResult()方法)，ServerSocket监听处理请求，在ZygoteConnection.run()方法中fork一个子进程并由子进程来处理。
//com.android.internal.os.ZygoteInit
void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
//....
while (true) {
//....
for (int i = pollFds.length - 1; i >= 0; --i) {
//...
if (i == 0) {
//获取Socket连接
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
//对每个连接调用runOnce处理
boolean done = peers.get(i).runOnce(this);
if (done) {
peers.remove(i);
fds.remove(i);
}
}
}
}
}
//com.android.internal.os.ZygoteConnection
boolean runOnce(ZygoteServer zygoteServer) throws Zygote.MethodAndArgsCaller {
//...
//fork出一个子进程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, fdsToIgnore, parsedArgs.instructionSet,
parsedArgs.appDataDir);
if (pid == 0) {
zygoteServer.closeServerSocket();
//...
//子进程处理函数
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
//...
}
//...
}
Zygote进程总结
流程图
- main方法中创建AppRuntime并调用其start方法
- 在runtime.start方法中创建DVM虚拟机，并未DVM注册JNI
- 通过JNI反射方式调用
ZygoteInit的mian函数进入Zygote的Java框架层 - 通过
registerZygoteSocket函数创建服务端的Socket,并通过runSelectLoop函数等待ActivityManagerService等请求来fork新的应用程序进程 - fork启动SystemServer进程
