Android系统启动分析(二)

最新推荐文章于 2023-07-17 23:22:49 发布
最新推荐文章于 2023-07-17 23:22:49 发布
阅读量415 收藏 1
点赞数
分类专栏： android源码 文章标签： Android Framework
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/unclePomelo/article/details/85113026
版权

本节是本系列文章的第二篇,将分析Zygote进程的启动过程。

第一篇文章:Android系统启动分析(一)
第三篇文章:Android系统启动分析(三)

二、Zygote进程启动

上节分析了Init进程的启动流程。本节将进入到framework层,分析Zygote进程的启动流程。

本节涉及到的文件有:

文件路径
app_main.cppframework/cmds/app_process/app_main.cpp
AndroidRuntime.cppframeworks/base/core/jni/AndroidRuntime.cpp
ZygoteInit.javaframeworks/base/core/java/com/android/internal/os/ZygoteInit.java
ZygoteServer.javaframeworks/base/core/java/com/android/internal/os/ZygoteServer.java

2.1 app_main.main()

大家都知道Zygote进程相当于是Android的根进程,后面所有进程都是该进程fork出来的,而Zygote进程则是由Init进程fork而来。先看看Zygote进程是如何启动的。
进入到app_main的main()函数

framework/cmds/app_process/app_main.cpp 
int main(int argc, char* const argv[])
{
    ……
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
	……
    //注释1:解析传进来的参数
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
        } 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;
        }
    }
    ……
    //注释2
    if (zygote) {
        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();
        ……
    }
}
  1. 注释1处:将解析传进来的参数,由init.zygote64_32.rc文件可知,传进来的参数为:"-Xzygote /system/bin --zygote --start-system-server --socket-name=zygote",因此argv[]数组大小为4,执行过注释1处的while循环后,zygote = true,startSystemServer = true
  2. 注释2处:将执行runtime.start(“com.android.internal.os.ZygoteInit”, args, zygote)

2.2 AppRuntime.start

framework/cmds/app_process/app_main.cpp

AppRuntime定义在app_main.cpp中

class AppRuntime : public AndroidRuntime
{
   ……
}

其父类为AndroidRuntime类,AppRuntime并没有实现start方法,因此前面的调用将会进入到AndroidRuntime的start()函数。

frameworks/base/core/jni/AndroidRuntime.cpp 
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
	……
	//获取根目录
    const char* rootDir = getenv("ANDROID_ROOT");
    if (rootDir == NULL) {
        rootDir = "/system";
        if (!hasDir("/system")) {
            LOG_FATAL("No root directory specified, and /android does not exist.");
            return;
        }
        setenv("ANDROID_ROOT", rootDir, 1);
    }

    //注释1:创建虚拟机
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    //回调AppRuntime的onVmCreate函数
    onVmCreated(env);

    //注释2:注册JNI函数
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }
	……
	
    //注释3:将classname的"."替换为"/"
    //如: "com.android.internal.os.ZygoteInit"替换为"com/android/internal/os/ZygoteInit"
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    //根据路径找到class文件
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
		……
    } else {
    	//注释4:通过反射找到ZygoteInit.main()函数
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
           ……
        } else {
        	//注释5:调用ZygoteInit.main()函数
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
        }
    }
    free(slashClassName);
    if (mJavaVM->DetachCurrentThread() != JNI_OK)
        ALOGW("Warning: unable to detach main thread\n");
    if (mJavaVM->DestroyJavaVM() != 0)
        ALOGW("Warning: VM did not shut down cleanly\n");
}

注释1处:jni_invocation.Init(NULL)初始化JNI,调用startVm() 创建Java虚拟机
注释2处:通过startReg()注册JNI函数,定义Android创建线程的函数:javaCreateThreadEtc
注释3处:toSlashClassName()将classname的".“替换为”/"
注释4、5:通过JNI调用ZygoteInit.main()函数,至此,Zygote进程来到了Java代码。

2.3 ZygoteInit.main()

frameworks/base/core/java/com/android/internal/os/ZygoteInit.java 
public static void main(String argv[]) {
	ZygoteServer zygoteServer = new ZygoteServer();
	……
	final Runnable caller;
    //注释1:设置DDMS可用
    RuntimeInit.enableDdms();

    boolean startSystemServer = false;
    String socketName = "zygote";
    String abiList = null;
    boolean enableLazyPreload = false;
    //根据参数处理一些标志
    for (int i = 1; i < argv.length; i++) {
        if ("start-system-server".equals(argv[i])) {
            startSystemServer = true;
        } else if ("--enable-lazy-preload".equals(argv[i])) {
            enableLazyPreload = true;
        } else if (argv[i].startsWith(ABI_LIST_ARG)) {
            abiList = argv[i].substring(ABI_LIST_ARG.length());
        } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
    		socketName = argv[i].substring(SOCKET_NAME_ARG.length());
        } else {
            throw new RuntimeException("Unknown command line argument: " + argv[i]);
        }
     }
	……
	//注释2:创建一个Server端的值为"zygote"的Socket
	zygoteServer.registerServerSocket(socketName);
	if (!enableLazyPreload) {
		//注释3
		preload(bootTimingsTraceLog);
	} else {
		Zygote.resetNicePriority();
	}

	// Zygote process unmounts root storage spaces.
	Zygote.nativeUnmountStorageOnInit();
	ZygoteHooks.stopZygoteNoThreadCreation();
	if (startSystemServer) {
		//注释4:启动SystemServer进程
		Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
		//在Zygote进程中,r == null;在子进程中,r != null
		if (r != null) {
			r.run();
			return;
		}
	}
		//注释5:死循环,等待客户端请求
		caller = zygoteServer.runSelectLoop(abiList);
	} catch (Throwable ex) {
		Log.e(TAG, "System zygote died with exception", ex);
		throw ex;
	} finally {
		zygoteServer.closeServerSocket();
	}
	if (caller != null) {
		caller.run();
	}
}

注释1处:设置DDMS可用,DDMS在Zygote进程刚刚开始启动时便已设置
注释2处:创建一个值为"zygote"的Socket服务端,可以看到这里Zygote作为Server端,处理客户端的请求
注释3处:初始化Zygote中需要的Class类,初始化各类系统资源和库
注释4处:fork一个SystemServer进程
注释5处:调用ZygoteServer的runSelectLoop方法等待客户端(AMS)的创建新进程的请求点我跳转

2.3.1 registerServerSocket
frameworks/base/core/java/com/android/internal/os/ZygoteServer.java 
void registerServerSocket(String socketName) {
	if (mServerSocket == null) {
		int fileDesc;
		//拼接SocketName,"ANDROID_SOCKET_"+socketName
		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);
			//创建Socket的本地服务端,将文件描述符赋值给LocalServerSocket
			mServerSocket = new LocalServerSocket(fd);
		} catch (IOException ex) {
			throw new RuntimeException(
					"Error binding to local socket '" + fileDesc + "'", ex);
		}
	}
}
2.3.2 预加载类和资源 preload()
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java 
static void preload(TimingsTraceLog bootTimingsTraceLog) {
	//预加载Zygote需要用到的Class类
	//class文件的地址为:"/system/etc/preloaded-classes"
	preloadClasses();
	//加载drawable和color等资源
	preloadResources();
	nativePreloadAppProcessHALs();
	//预加载OpenGL
	preloadOpenGL();
	//调用System.loadLibrary()预加载"android"、"compiler_rt"、"jnigraphics"三个共享库
	preloadSharedLibraries();
	//初始化字体资源
	preloadTextResources();
	WebViewFactory.prepareWebViewInZygote();
	warmUpJcaProviders();
}
2.3.3 forkSystemServer()
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java 
private static Runnable forkSystemServer(String abiList, String socketName,
		ZygoteServer zygoteServer) {
	……
	//注释1:准备一些启动参数
	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 {
		//注释2:将启动参数封装到ZygoteConnection.Arguments中
		parsedArgs = new ZygoteConnection.Arguments(args);
		ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
		ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
		//注释3:调用Zygote.forkSystemServer()
		pid = Zygote.forkSystemServer(
				parsedArgs.uid, parsedArgs.gid,
				parsedArgs.gids,
				parsedArgs.debugFlags,
				null,
				parsedArgs.permittedCapabilities,
				parsedArgs.effectiveCapabilities);
	} catch (IllegalArgumentException ex) {
		throw new RuntimeException(ex);
	}
	
	//如果pid == 0,当前代码逻辑运行在子进程中
	if (pid == 0) {
		//如果有第二个Zygote,则等待第二个Zygote连接
		if (hasSecondZygote(abiList)) {
			waitForSecondaryZygote(socketName);
		}
		zygoteServer.closeServerSocket();
		//注释4:处理SystemServer进程
		return handleSystemServerProcess(parsedArgs);
	}
	return null;
}

注释1处:准备一些SystemServer进程的启动参数,类名为:com.android.server.SystemServer
注释2处:将启动参数封装到ZygoteConnection.Arguments中,具体在ZygoteConnection#parseArgs(),这里不再详细分析。
注释3处:调用Zygote.forkSystemServer(),可以看到SystemServer进程是被Zygote进程fork而来。最后会通过native方法nativeForkSystemServer()创建新进程。关于nativeForkSystemServer()的实现,可见frameworks/base/core/jni/com_android_internal_os_Zygote.cpp
注释4处:如果注释3处返回的pid == 0,则此时代码逻辑运行在子进程中,这里会调用handleSystemServerProcess()来处理SystemServer进程。
关于SysetmServer进程,将在第三节分析。点我跳转

2.3.4 runSelectLoop()

Runnable runSelectLoop(String abiList) {
	ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
	ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
	//注释1:添加服务端的文件描述符到一个集合中
	fds.add(mServerSocket.getFileDescriptor());
	peers.add(null);
	//死循环,等待AMS的请求
	while (true) {
		StructPollfd[] pollFds = new StructPollfd[fds.size()];
		//将要观察的fd建立成数组
		for (int i = 0; i < pollFds.length; ++i) {
			pollFds[i] = new StructPollfd();
			pollFds[i].fd = fds.get(i);
			pollFds[i].events = (short) POLLIN;
		}
		try {
			//注释2:阻塞等待fd的变化
			Os.poll(pollFds, -1);
		} catch (ErrnoException ex) {
			throw new RuntimeException("poll failed", ex);
		}
		//注释3:当fd有变化时(客户端有连接时),会进入该for循环
		for (int i = pollFds.length - 1; i >= 0; --i) {
			if ((pollFds[i].revents & POLLIN) == 0) {
				continue;
			}

			if (i == 0) {
				//注释4:fds[0],即mServerSocket对象
				ZygoteConnection newPeer = acceptCommandPeer(abiList);
				peers.add(newPeer);
				fds.add(newPeer.getFileDesciptor());
			} else {
				try {
					//注释5:
					ZygoteConnection connection = peers.get(i);
					final Runnable command = connection.processOneCommand(this);
					if (mIsForkChild) {
						……
                        return command;
					}
				} catch (Exception e) {
					……
				}
			}
		}
	}
}

注释1处:添加服务端的文件描述符到fds集合中,文件描述符是在ZygoteServer.registerServerSocket()中创建,并封装给LocalServerSocket
注释2处:该处语句会阻塞,若fd发生变化,则解除阻塞状态
注释3处:若注释2处的语句解除阻塞,则会执行该处的for循环
注释4处: i==0时,意味着有客户端连接请求,创建新连接并处理请求
注释5处: i>0,说明客户端(AMS)向Zygote发送了一个创建应用进程的请求,processOneCommand()方法会调用Zygote.forkAndSpecialize() fork一个新的VM实例,最终会进入到com_android_internal_os_Zygote.nativeForkAndSpecialize()函数。由于篇幅限制,这里不做过多介绍,感兴趣的读者可以自己去看。

2.4 Zygote进程启动总结

Zygote进程启动过程中主要做了以下几件事:

  1. 调用AppRuntime.start()方法创建Java虚拟机,注册JNI函数
  2. 通过JNI调用ZygoteInit.main()方法
  3. 创建一个值为"zygote"的Socket服务端
  4. 预加载类和资源
  5. 创建SystemServer进程,并通过runSelectLoop()进入死循环监听Socket消息

Zygote进程的启动分析到这里结束。下一节将介绍SystemServer进程的启动过程。

柚子_J
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android系统启动分析(一)
柚子Jiang
12-20 650
Android系统启动分析一一、init进程启动1.1 init.main()1.2 解析init.rc1.2.1 解析service1.2.2 启动ServiceManager1.2.3 启动Zygote1.3 小结 本文的分析基于Android 8.1源码。 Android系统启动与应用程序的启动流程、四大组件原理、AMS、ClassLoader等息息相关，因此了解Android系统启动流程对...
Android 系统启动分析
crazyZhangxl的博客
05-27 423
简述 本文简要记录下学习Android系统启动的一些细节，方便自己记忆和宏观的认识
Android 8.1 zygote创建新应用进程
长乐居士
01-02 1004
Android 8.1 zygote创建新应用进程 涉及到的文件以及路径： frameworks/base/core/java/com/android/internal/os/Zygote.java frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java frameworks/base/core/java/...
android启动过程深入解析,Android 8.1 源码_启动篇（二） -- 深入研究 zygote
weixin_31434215的博客
05-25 464
前言在Android中，zygote是整个系统创建新进程的核心进程。zygote进程在内部会先启动Dalvik虚拟机，继而加载一些必要的系统资源和系统类，最后进入一种监听状态。在之后的运作中，当其他系统模块(比如 AMS)希望创建新进程时，只需向zygote进程发出请求，zygote进程监听到该请求后，会相应地fork出新的进程，于是这个新进程在初生之时，就先天具有了自己的Dalvik虚拟机以及系...
安卓系统启动之Zygote进程启动过程
四国棋客
07-24 1286
背景 安卓系统启动时首先启动init进程，而后init进程会创建zygote进程，zygote进程则会fork出来SystemServer进程。在安卓开发学习之SystemServer启动过程一文中记录了阅读SystemServer启动的过程，现在就记录一下Zygote进程的启动过程   源码阅读 Zygote进程的启动源自于ZygoteInit类的入口main()方法 ZygoteIn...
Android 开发错误集合
我很好
02-14 2159
???? java.lang.RuntimeException: Unable to start activity ComponentInfo ???? E/AndroidRuntime: FATAL EXCEPTION: main Process: org.kotlin.async.task, PID: 6571 java.lang.RuntimeException: Unable to start activity ComponentInfo{org.kotlin.async.tas
Android 系统启动流程
u010783226的专栏
08-20 401
1. Init 进程启动流程 2. Zygote启动流程 3. SystemServer启动流程 1. Init 进程启动流程 Android启动流程 init进程 –> Zygote进程 –> SystemServer进程 –> 各种应用进程 Init 进程 init是第一个进程，我们可以说它是root进程或者说有进程的父进程。init进程有两个责任， 一是挂载目录，比如/sys、/dev、/proc， 二是运行init.rc脚本。 init进程...
Android 系统启动流程源码分析
最新发布
05-07
Android 系统启动流程源码分析
Android系统启动分析.pdf
10-02
Android系统的启动过程是一个复杂而有序的序列，涉及多个层次的组件和交互。首先，我们从系统的引导阶段开始。 1. **系统引导 (Bootloader)** Bootloader是系统启动的第一步，它的源码位于`bootable/bootloader/`...
Android 系统服务TelecomService启动过程原理分析
08-18
Android 系统服务TelecomService 启动过程原理分析 Android 系统服务TelecomService 是 Android 系统的一个核心服务，主要负责管理 Android 系统当前的通话，包括来电显示、接听电话、挂断电话等功能。在 Telephony...
Android 系统启动流分析 & Zygote启动流程分析
01-03
Zygote在Android系统扮演着不可或缺的角色,Android系统的启动首先需要Zygote参与,比如启动SystemService , 还有一个就是孵化应用的进程,比如我们创建一个Activity也是需要Zygote参与.  Zygote 启动分为两个部分: 1....
Android Service启动过程完整分析
09-01
理解这一过程对于深入掌握Android系统的工作原理和优化Service的使用至关重要。在实际开发中，合理利用Service的特性，能够实现各种后台任务，如音乐播放、定时任务等，同时注意避免主线程阻塞，保证用户体验。
Android TV开机优化
he980725866的博客
02-20 4227
Android开机优化
Zygote进程简介
NIIIICO的博客
12-20 1374
本文基于Android_9.0、kernel_3.18源码 #Android手机进程 打开控制台，使用adb shell，然后执行ps -A命令；便可看到Android系统中运行的进程。PID是进程号，PPID是父进程号。PID越小启动越早。 通过梳理我们可以得到以下的关系图： #init进程 打开android手机后，会先启动bootloader引导程序，当kernel完成系统设置后，它会拉起init进程。init进程主要进行文件夹创建挂载、init.rc文件解析等操作。 system/core/
Android P 之Zygote进程源码分析
s_nshine的博客
07-17 258
c++世界(app_main.cpp入口)：动态加载虚拟机动态库，启动java虚拟机注册JNI本地函数，减轻虚拟机负担装载ZygoteInit到java虚拟机，正式进入java世界java世界（ZygoteInit.java入口）：绑定套接字，用来接收新Android应用程序运行请求预加载Android资源，提高应用进程启动速度启动并运行SystemServer（运行AMS、PMS等核心服务）处理新Android应用程序运行请求。
Android开机流程、Zygote进程、systemserver、ServiceManager
AndroidDeveloper的专栏
05-25 1989
上电后，BootRom会被激活，引导芯片代码开始从预定义的地方（固化在ROM）开始执行，然后加载引导程序到RAM。Android是基于Linux系统的，它没有BIOS程序，取而代之的是（系统启动引导程序）。引导程序是厂商加锁和限制的地方，它是针对特定的主板与芯片的。厂商要么使用很受欢迎的引导程序比如redbootubootARMboot等或者开发自己的引导程序，它不是Android操作系统的一部分。流程图如下：Linux内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。
Android开机启动流程简析
bosswcz的博客
06-22 6396
在学习Android过程中开机启动是必要了解的,在这里我主要谈一谈我所学习的看法和经验,可能总结的不到位,一起交流一下
Android 系统开发_启动阶段篇 -- 深入钻研 zygote
weixin_33953249的博客
08-09 475
前言 在Android中，zygote是整个系统创建新进程的核心进程。zygote进程在内部会先启动Dalvik虚拟机，继而加载一些必要的系统资源和系统类，最后进入一种监听状态。在之后的运作中，当其他系统模块（比如 AMS）希望创建新进程时，只需向zygote进程发出请求，zygote进程监听到该请求后，会相应地fork出新的进程，于是这...
Android 7.0 Launcher3的启动和加载流程分析
柚子Jiang
08-21 3919
本文的分析基于MTK提供的Android 7.0源码，并非Google官方提供的源码，其中可能有一些小的差异，还望谅解。 Launcher的本质就是一个普通应用，它比普通应用多配置了Category的Android:name=”android.intent.category.HOME”属性，之后ActivityManagerService的startHomeActivityLocked方法将启动含
Android系统-源码阅读-系统启动流程笔记
03-16
Android系统启动流程源码分析； init进程的启动； 各个守护进程的启动； Zygote的启动； SystemServer的启动；

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值