AMS 到 Zygote fork进程到ActivityThread

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zgkxzx/article/details/84700408

AMS 到 Zygote fork进程前半段

ActivityStackSupervisor#startSpecificActivityLocked

void startSpecificActivityLocked(ActivityRecord r,  boolean andResume, boolean checkConfig)
{
	// Is this activity's application already running?
  //AMS里面通过查表获取当前APP的ProcessRecord 进程记录信息
	ProcessRecord app = mService.getProcessRecordLocked(r.processName,
	                    r.info.applicationInfo.uid, true);

	r.task.stack.setLaunchTime(r);
  /**
  *这里就是APP 冷启动和热启动的区分
  * 查表里面直接找到 那么调用AMS内部的Activity打开方法，讲栈顶的Activity置为前台
  * 如果找不到，通过AMS 为此APP创建新的进程
  */
  //判断是否为空 不为空说明进程中已经存在 打开此APP
	if (app != null && app.thread != null) {
		try {
			if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
			          || !"android".equals(r.info.packageName)) {
				// Don't add this if it is a platform component that is marked
				// to run in multiple processes, because this is actually
				// part of the framework so doesn't make sense to track as a
				// separate apk in the process.
				app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
				               mService.mProcessStats);
			}
      //开启Activity
			realStartActivityLocked(r, app, andResume, checkConfig);
			return;
		} catch (RemoteException e) {
			Slog.w(TAG, "Exception when starting activity "
			       + r.intent.getComponent().flattenToShortString(), e);
		}

		// If a dead object exception was thrown -- fall through to
		// restart the application.
	}
  //通过AMS创建新的进程
	mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
	                            "activity", r.intent.getComponent(), false, false, true);
}

ActivityManagerService#startProcessLocked

final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
                                       boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
                                       boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
                                       String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler)
{
	long startTime = SystemClock.elapsedRealtime();
	ProcessRecord app;
	...

	//开启新进程的一些准备

	...
	startProcessLocked(
	     app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);
	checkTime(startTime, "startProcess: done starting proc!");
	return (app.pid != 0) ? app : null;
}

//接着调用这个startProcessLocked方法
private final void startProcessLocked(ProcessRecord app, String hostingType,
                                      String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs)
{
	long startTime = SystemClock.elapsedRealtime();
	...

	// Start the process.  It will either succeed and return a result containing
	// the PID of the new process, or else throw a RuntimeException.
	boolean isActivityProcess = (entryPoint == null);
	if (entryPoint == null) entryPoint = "android.app.ActivityThread";
	checkTime(startTime, "startProcess: asking zygote to start proc");
	//通过调用Process的start方法去开启新进程
	Process.ProcessStartResult startResult = Process.start(entryPoint,
	          app.processName, uid, uid, gids, debugFlags, mountExternal,
	          app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
	          app.info.dataDir, entryPointArgs);
	...
}

Process#start

//start
public static final ProcessStartResult start(final String processClass,
          final String niceName,
          int uid, int gid, int[] gids,
          int debugFlags, int mountExternal,
          int targetSdkVersion,
          String seInfo,
          String abi,
          String instructionSet,
          String appDataDir,
          String[] zygoteArgs)
{
	try {
    //调用startViaZygote
		return startViaZygote(processClass, niceName, uid, gid, gids,
		                      debugFlags, mountExternal, targetSdkVersion, seInfo,
		                      abi, instructionSet, appDataDir, zygoteArgs);
	} catch (ZygoteStartFailedEx ex) {
		Log.e(LOG_TAG,
		      "Starting VM process through Zygote failed");
		throw new RuntimeException(
		     "Starting VM process through Zygote failed", ex);
	}
}

//startViaZygote
private static ProcessStartResult startViaZygote(final String processClass,
          final String niceName,
          final int uid, final int gid,
          final int[] gids,
          int debugFlags, int mountExternal,
          int targetSdkVersion,
          String seInfo,
          String abi,
          String instructionSet,
          String appDataDir,
          String[] extraArgs)
          throws ZygoteStartFailedEx {
		//配置一些启动参数
    //连接Zygote Socket 发送参数开启进程
		return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
	}
}

//openZygoteSocketIfNeeded
private static ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
	if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
		try {
			//与Zygote进程建立连接 连接名为ZYGOTE_SOCKET的Socket
			primaryZygoteState = ZygoteState.connect(ZYGOTE_SOCKET);
		} catch (IOException ioe) {
			throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
		}
	}
	//判断是否匹配ABI
	if (primaryZygoteState.matches(abi)) {
		return primaryZygoteState;
	}
	//如果不匹配尝试第二种连接方式
	// The primary zygote didn't match. Try the secondary.
	if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
		try {

			secondaryZygoteState = ZygoteState.connect(SECONDARY_ZYGOTE_SOCKET);
		} catch (IOException ioe) {
			throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
		}
	}
	//判断是否匹配ABI
	if (secondaryZygoteState.matches(abi)) {
		return secondaryZygoteState;
	}
	//还不匹配，那么抛出异常
	throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}

Zygote fork进程到ActivityThread

ZygoteInit#main

//main
public static void main(String argv[])
{
	try {
		// Start profiling the zygote initialization.
		SamplingProfilerIntegration.start();

		boolean startSystemServer = false;
		String socketName = "zygote";
		String abiList = null;
		//添加参数
		for (int i = 1; i < argv.length; i++) {
			if ("start-system-server".equals(argv[i])) {
				startSystemServer = 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]);
			}
		}

		if (abiList == null) {
			throw new RuntimeException("No ABI list supplied.");
		}
		//注册ZygoteSocket
		registerZygoteSocket(socketName);
		EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
		                    SystemClock.uptimeMillis());
		//预加载资源
		preload();
		EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
		                    SystemClock.uptimeMillis());

		// Finish profiling the zygote initialization.
		SamplingProfilerIntegration.writeZygoteSnapshot();

		// Do an initial gc to clean up after startup
		//gc
		//运行gc();

		// Disable tracing so that forked processes do not inherit stale tracing tags from
		// Zygote.
		Trace.setTracingEnabled(false);

		//开启SystemServer
		if (startSystemServer) {
			startSystemServer(abiList, socketName);
		}

		Log.i(TAG, "Accepting command socket connections");
		//运行一个Loop循环接受Socket发来的请求
		runSelectLoop(abiList);

		closeServerSocket();
	} catch (MethodAndArgsCaller caller) {
		//执行反射 调用ActivityThread main方法
		caller.run();
	} catch (RuntimeException ex) {
		Log.e(TAG, "Zygote died with exception", ex);
		closeServerSocket();
		throw ex;
	}
}
//runSelectLoop
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
	ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
	ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
	FileDescriptor[] fdArray = new FileDescriptor[4];

	fds.add(sServerSocket.getFileDescriptor());
	peers.add(null);

	int loopCount = GC_LOOP_COUNT;
	while (true) {
		int index;

		...
		if (index < 0) {
			throw new RuntimeException("Error in select()");
		} else if (index == 0) {
			//接受Zygote Socket发来的请求
			ZygoteConnection newPeer = acceptCommandPeer(abiList);
			peers.add(newPeer);
			fds.add(newPeer.getFileDescriptor());
		} else {
			boolean done;
			//处理客户端数据事务
			done = peers.get(index).runOnce();

			if (done) {
				peers.remove(index);
				fds.remove(index);
			}
		}
	}
}

ZygoteConnection#runOnce

//runOnce
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {

	String args[];
	Arguments parsedArgs = null;
	FileDescriptor[] descriptors;

	...

	try {
		//调用Zygote forkAndSpecialize方法fork新进程
		pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
		parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
		parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
		parsedArgs.appDataDir);
		checkTime(startTime, "zygoteConnection.runOnce: postForkAndSpecialize");
	} catch (IOException ex) {
		logAndPrintError(newStderr, "Exception creating pipe", ex);
	} catch (ErrnoException ex) {
		logAndPrintError(newStderr, "Exception creating pipe", ex);
	} catch (IllegalArgumentException ex) {
		logAndPrintError(newStderr, "Invalid zygote arguments", ex);
	} catch (ZygoteSecurityException ex) {
		logAndPrintError(newStderr,
		                 "Zygote security policy prevents request: ", ex);
	}
  try
  {
  	if (pid == 0) {
  		// in child
  		IoUtils.closeQuietly(serverPipeFd);
  		serverPipeFd = null;
      //处理子进程
  		handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);

  		// should never get here, the child is expected to either
  		// throw ZygoteInit.MethodAndArgsCaller or exec().
  		return true;
  	} else {
  		// in parent...pid of < 0 means failure
  		IoUtils.closeQuietly(childPipeFd);
  		childPipeFd = null;
  		return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
  	}
  }
  finally {
  	IoUtils.closeQuietly(childPipeFd);
  	IoUtils.closeQuietly(serverPipeFd);
  }
	...
}
//handleChildProc
private void handleChildProc(Arguments parsedArgs,
                             FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
throws ZygoteInit.MethodAndArgsCaller {

	/**
	 * By the time we get here, the native code has closed the two actual Zygote
	 * socket connections, and substituted /dev/null in their place.  The LocalSocket
	 * objects still need to be closed properly.
	 */

	closeSocket();
	ZygoteInit.closeServerSocket();

	...

	if (parsedArgs.invokeWith != null) {
		WrapperInit.execApplication(parsedArgs.invokeWith,
		parsedArgs.niceName, parsedArgs.targetSdkVersion,
		pipeFd, parsedArgs.remainingArgs);
	} else {
		RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
		parsedArgs.remainingArgs, null /* classLoader */);
	}
	...

}

RuntimeInit#zygoteInit

//zygoteInit
public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
	if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
	//
	redirectLogStreams();
	//共同初始化
	commonInit();
	//本地Zygote初始化
	nativeZygoteInit();
	//Application init
	applicationInit(targetSdkVersion, argv, classLoader);
}
//applicationInit
private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {

	nativeSetExitWithoutCleanup(true);

	//设置虚拟机的堆参数
	VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
	VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);


	//通过反射调用ActivityThread的main方法
	invokeStaticMain(args.startClass, args.startArgs, classLoader);
}

Zygote#forkAndSpecialize

//forkAndSpecialize
public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
                                    int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
                                    String instructionSet, String appDataDir)
{
	long startTime = SystemClock.elapsedRealtime();

	//调用nativeForkAndSpecialize本地方法
	int pid = nativeForkAndSpecialize(
	               uid, gid, gids, debugFlags, rlimits, mountExternal, seInfo, niceName, fdsToClose,
	               instructionSet, appDataDir);

	return pid;
}

Zygote#nativeForkAndSpecialize

//com_android_internal_os_Zygote.cpp

//com_android_internal_os_Zygote_nativeForkAndSpecialize
static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(
        JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
        jint debug_flags, jobjectArray rlimits,
        jint mount_external, jstring se_info, jstring se_name,
        jintArray fdsToClose, jstring instructionSet, jstring appDataDir) {
    // Grant CAP_WAKE_ALARM to the Bluetooth process.
    jlong capabilities = 0;
    if (uid == AID_BLUETOOTH) {
        capabilities |= (1LL << CAP_WAKE_ALARM);
    }

    return ForkAndSpecializeCommon(env, uid, gid, gids, debug_flags,
            rlimits, capabilities, capabilities, mount_external, se_info,
            se_name, false, fdsToClose, instructionSet, appDataDir);
}
//ForkAndSpecializeCommon
static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids,
                                     jint debug_flags, jobjectArray javaRlimits,
                                     jlong permittedCapabilities, jlong effectiveCapabilities,
                                     jint mount_external,
                                     jstring java_se_info, jstring java_se_name,
                                     bool is_system_server, jintArray fdsToClose,
                                     jstring instructionSet, jstring dataDir)
{
	uint64_t start = MsTime();
	SetSigChldHandler();
	ckTime(start, "ForkAndSpecializeCommon:SetSigChldHandler");
	//fork 一个新的进程
	pid_t pid = fork();
	//子进程的处理
	if (pid == 0) {
		// The child process.
		gMallocLeakZygoteChild = 1;


		// Clean up any descriptors which must be closed immediately
		DetachDescriptors(env, fdsToClose);

		ckTime(start, "ForkAndSpecializeCommon:Fork and detach");

		// Keep capabilities across UID change, unless we're staying root.
		if (uid != 0) {
			EnableKeepCapabilities(env);
		}

		DropCapabilitiesBoundingSet(env);

		bool use_native_bridge = !is_system_server && (instructionSet != NULL)
		                         && android::NativeBridgeAvailable();
		...
		//创建一些进程组设置参数
		...
		SetGids(env, javaGids);

		SetRLimits(env, javaRlimits);


		SetCapabilities(env, permittedCapabilities, effectiveCapabilities);

		SetSchedulerPolicy(env);

		...
		rc = selinux_android_setcontext(uid, is_system_server, se_info_c_str, se_name_c_str);

		//反射调用 zygote. callPostForkChildHooks()
		env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, debug_flags,
		                          is_system_server ? NULL : instructionSet);
		ckTime(start, "ForkAndSpecializeCommon:PostForkChildHooks returns");
		if (env->ExceptionCheck()) {
			ALOGE("Error calling post fork hooks.");
			RuntimeAbort(env);
		}
	} else if (pid > 0) {
		//父进程
		// the parent process
	}
	return pid;
}