AMS如何启动一个新的进程
在AMS中启动进程有两种方式
1:启动进程 startProcessLocked
startProcessLocked启动进程的流程
startProcessLocked方法有很多同名函数，但是最终都会调用以下这个函数
private boolean startProcessLocked(String hostingType, String hostingNameStr, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime)
- hostingType：启动进程的过程是由启动组件触发的，这个就是由指哪一个类型组件触发的, 启动activity，这个值就是“activity”, 启动service这个值就是“service”,启动contentprovider这个值就是”content provider”，启动广播接收器这个值就是”broadcast”，启动backup这个值就是”backup”
- hostingName：启动进程的过程是由启动组件触发的，这个值就是指启动组件的信息
- entryPoint：要启动的哪个类main方法，此处应该是ActivityThread
- app：进程的ProcessRecord对象
- uid：当前进程的uid
- gid：进程的gid信息
- runtingflags：进程启动的一些参数
- mountExternal：当前进程挂载信息？
- seine：进程的selinux信息
startProcessLocked启动流程
@GuardedBy("this")
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;
//如果已经有档期的ProcessRecord记录，且App.pid>0,表示已经有实际进程和当前record关联
//如果app.thread = null，或者当前进程为被kill掉，则直接将package添加到当前进程，
//否则杀死当前进程
if (app != null && app.pid > 0) {
if ((!knownToBeDead && !app.killed) || app.thread == null) {
// We already have the app running, or are waiting for it to
// come up (we have a pid but not yet its thread), so keep it.
if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "App already running: " + app);
// If this is a new package in the process, add the package to the list
app.addPackage(info.packageName, info.versionCode, mProcessStats);
checkTime(startTime, "startProcess: done, added package to proc");
return app;
}
// An application record is attached to a previous process,
// clean it up now.
if (DEBUG_PROCESSES || DEBUG_CLEANUP) Slog.v(TAG_PROCESSES, "App died: " + app);
checkTime(startTime, "startProcess: bad proc running, killing");
killProcessGroup(app.uid, app.pid);
handleAppDiedLocked(app, true, true);
checkTime(startTime, "startProcess: done killing old proc");
}
//如果app == null, 直接创建一个ProcessRecord
String hostingNameStr = hostingName != null
? hostingName.flattenToShortString() : null;
if (app == null) {
checkTime(startTime, "startProcess: creating new process record");
app = newProcessRecordLocked(info, processName, isolated, isolatedUid);
if (app == null) {
Slog.w(TAG, "Failed making new process record for "
+ processName + "/" + info.uid + " isolated=" + isolated);
return null;
}
app.crashHandler = crashHandler;
app.isolatedEntryPoint = entryPoint;
app.isolatedEntryPointArgs = entryPointArgs;
checkTime(startTime, "startProcess: done creating new process record");
} else {
// 如果是新的package,则添加到当前进程
app.addPackage(info.packageName, info.versionCode, mProcessStats);
checkTime(startTime, "startProcess: added package to existing proc");
}
// 如果系统还未启动完成，则将要启动进程的processRecord存放到mProcessesOnHold列表，等待系统启动完成后处理
if (!mProcessesReady
&& !isAllowedWhileBooting(info)
&& !allowWhileBooting) {
if (!mProcessesOnHold.contains(app)) {
mProcessesOnHold.add(app);
}
if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES,
"System not ready, putting on hold: " + app);
checkTime(startTime, "startProcess: returning with proc on hold");
return app;
}
checkTime(startTime, "startProcess: stepping in to startProcess");
//接着调用另一个同名方法启动进程
final boolean success = startProcessLocked(app, hostingType, hostingNameStr, abiOverride);
checkTime(startTime, "startProcess: done starting proc!");
return success ? app : null;
}
- 查询进程记录表
如果进程记录表的pid>0，证明进程记录表有效，检查是否进程已经在启动，如果已经在启动的话，添加package信息，直接返回，否则的话，调用handleAppDiedLocked（）复位进程记录表 - 如果进程记录表不存在，调用newProcessRecordLocked（）创建进程记录表，如果存在，直接添加package的信息
- 如果不允许启动，添加到进程挂起容器（mProcessesOnHold），直接返回
- 调用同名方法启动进程
private final boolean startProcessLocked(ProcessRecord app, String hostingType,
String hostingNameStr, boolean disableHiddenApiChecks, String abiOverride) {
//将当前进程从mProcessesOnHold中移除，现在已经开始启动进程了
mProcessesOnHold.remove(app);
try {
//设置新进程的挂载信息
int uid = app.uid;
int[] gids = null;
int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;
if (!app.isolated) {
int[] permGids = null;
try {
checkTime(startTime, "startProcess: getting gids from package manager");
final IPackageManager pm = AppGlobals.getPackageManager();
permGids = pm.getPackageGids(app.info.packageName,
MATCH_DEBUG_TRIAGED_MISSING, app.userId);
StorageManagerInternal storageManagerInternal = LocalServices.getService(
StorageManagerInternal.class);
mountExternal = storageManagerInternal.getExternalStorageMountMode(uid,
app.info.packageName);
} catch (RemoteException e) {
throw e.rethrowAsRuntimeException();
}
/*
* 设置新进程的gids信息，以方便新的进程可以共享一些预加载的系统资源
*/
if (ArrayUtils.isEmpty(permGids)) {
gids = new int[3];
} else {
gids = new int[permGids.length + 3];
System.arraycopy(permGids, 0, gids, 3, permGids.length);
}
gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));
gids[1] = UserHandle.getCacheAppGid(UserHandle.getAppId(uid));
gids[2] = UserHandle.getUserGid(UserHandle.getUserId(uid));
// Replace any invalid GIDs
if (gids[0] == UserHandle.ERR_GID) gids[0] = gids[2];
if (gids[1] == UserHandle.ERR_GID) gids[1] = gids[2];
}
checkTime(startTime, "startProcess: building args");
if (mFactoryTest != FactoryTest.FACTORY_TEST_OFF) {
if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
&& mTopComponent != null
&& app.processName.equals(mTopComponent.getPackageName())) {
uid = 0;
}
if (mFactoryTest == FactoryTest.FACTORY_TEST_HIGH_LEVEL
&& (app.info.flags&ApplicationInfo.FLAG_FACTORY_TEST) != 0) {
uid = 0;
}
}
//设置新启动的runtime_flag信息
int runtimeFlags = 0;
if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
runtimeFlags |= Zygote.DEBUG_ENABLE_JDWP;
runtimeFlags |= Zygote.DEBUG_JAVA_DEBUGGABLE;
// Also turn on CheckJNI for debuggable apps. It's quite
// awkward to turn on otherwise.
runtimeFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;
}
// Run the app in safe mode if its manifest requests so or the
// system is booted in safe mode.
if ((app.info.flags & ApplicationInfo.FLAG_VM_SAFE_MODE) != 0 ||
mSafeMode == true) {
runtimeFlags |= Zygote.DEBUG_ENABLE_SAFEMODE;
}
......
// 设置新进程的selinux信息
if (TextUtils.isEmpty(app.info.seInfoUser)) {
Slog.wtf(TAG, "SELinux tag not defined",
new IllegalStateException("SELinux tag not defined for "
+ app.info.packageName + " (uid " + app.uid + ")"));
}
final String seInfo = app.info.seInfo
+ (TextUtils.isEmpty(app.info.seInfoUser) ? "" : app.info.seInfoUser);
//设置新进程启动的入口函数
final String entryPoint = "android.app.ActivityThread";
//调用同名方法启动新进程
return startProcessLocked(hostingType, hostingNameStr, entryPoint, app, uid, gids,
runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
startTime);
} catch (RuntimeException e) {
Slog.e(TAG, "Failure starting process " + app.processName, e);
// 设置失败，强制停止
forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid), false,
false, true, false, false, UserHandle.getUserId(app.userId), "start failure");
return false;
}
}
这个函数主要是为新启动的进程设置参数
- 设置新进程的挂载信息
- 设置新进程的gid信息
- 设置新进程的runtime flag信息
- 设置新进程的selinux信息
- 设置新进程的入口函数
private boolean startProcessLocked(String hostingType, String hostingNameStr, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
//初始化新进程的信息
app.pendingStart = true;
app.killedByAm = false;
app.removed = false;
app.killed = false;
final long startSeq = app.startSeq = ++mProcStartSeqCounter;
app.setStartParams(uid, hostingType, hostingNameStr, seInfo, startTime);
//启动新进程方式有两种
//1: 异步方式启动
if (mConstants.FLAG_PROCESS_START_ASYNC) {
if (DEBUG_PROCESSES) Slog.i(TAG_PROCESSES,
"Posting procStart msg for " + app.toShortString());
mProcStartHandler.post(() -> {
try {
synchronized (ActivityManagerService.this) {
final String reason = isProcStartValidLocked(app, startSeq);
if (reason != null) {
Slog.w(TAG_PROCESSES, app + " not valid anymore,"
+ " don't start process, " + reason);
app.pendingStart = false;
return;
}
app.usingWrapper = invokeWith != null
|| SystemProperties.get("wrap." + app.processName) != null;
mPendingStarts.put(startSeq, app);
}
final ProcessStartResult startResult = startProcess(app.hostingType, entryPoint,
app, app.startUid, gids, runtimeFlags, mountExternal, app.seInfo,
requiredAbi, instructionSet, invokeWith, app.startTime);
synchronized (ActivityManagerService.this) {
handleProcessStartedLocked(app, startResult, startSeq);
}
} catch (RuntimeException e) {
synchronized (ActivityManagerService.this) {
Slog.e(TAG, "Failure starting process " + app.processName, e);
mPendingStarts.remove(startSeq);
app.pendingStart = false;
forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid),
false, false, true, false, false,
UserHandle.getUserId(app.userId), "start failure");
}
}
});
return true;
} else {
//2:同步方式启动
try {
final ProcessStartResult startResult = startProcess(hostingType, entryPoint, app,
uid, gids, runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet,
invokeWith, startTime);
handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
startSeq, false);
} catch (RuntimeException e) {
Slog.e(TAG, "Failure starting process " + app.processName, e);
app.pendingStart = false;
forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid),
false, false, true, false, false,
UserHandle.getUserId(app.userId), "start failure");
}
return app.pid > 0;
}
- 根据设置，可采用异步活着同步两种方式启动新的进程
启动新进程调用方法startProcess, 该方法和Zygote进行通信，通知Zygote孵化一个新的进程，然后执行新进程的ActivityThread.main方法，启动完成后会返回新进程的pid进程号
@GuardedBy("this")
private boolean handleProcessStartedLocked(ProcessRecord app, int pid, boolean usingWrapper,
long expectedStartSeq, boolean procAttached) {
//检查新启动的reason,如果不合法则杀死该进程
final String reason = isProcStartValidLocked(app, expectedStartSeq);
if (reason != null) {
Slog.w(TAG_PROCESSES, app + " start not valid, killing pid=" + pid
+ ", " + reason);
app.pendingStart = false;
Process.killProcessQuiet(pid);
Process.killProcessGroup(app.uid, app.pid);
return false;
}
//presistent进行需要设置WatchDog
if (app.persistent) {
Watchdog.getInstance().processStarted(app.processName, pid);
}
//将新进程的pid进程号设置到ProcessRecord中，此时已经有一个进程和当前的ProcessRecord对应了
app.setPid(pid);
app.usingWrapper = usingWrapper;
app.pendingStart = false;
checkTime(app.startTime, "startProcess: starting to update pids map");
ProcessRecord oldApp;
synchronized (mPidsSelfLocked) {
oldApp = mPidsSelfLocked.get(pid);
}
// 如果该进程号曾今对应另外一个进程，则将另外一个进程杀掉
if (oldApp != null && !app.isolated) {
cleanUpApplicationRecordLocked(oldApp, false, false, -1,
true /*replacingPid*/);
}
//将进程添加到mPidsSelfLocked列表中
synchronized (mPidsSelfLocked) {
this.mPidsSelfLocked.put(pid, app);
if (!procAttached) {
Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);
msg.obj = app;
mHandler.sendMessageDelayed(msg, usingWrapper
? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);
}
}
checkTime(app.startTime, "startProcess: done updating pids map");
return true;
}
该方法主要做进程启动的善后处理
- 检查新启动的reason,如果不合法则杀死该进程
- presistent进行需要设置WatchDog
- 将新进程的pid进程号设置到ProcessRecord中，此时就有一个进程和当前的ProcessRecord对应了
- 将进程添加到mPidsSelfLocked列表中，如果当前进程PID在列表中有对应启动ProcessRecord，则先杀掉旧的进程.
至此新进程就启动完成了.
startProcessLocked方法，创建了对应进程的ProcessRecord管理信息，还调用Zygote启动一个真正的进程
进程启动方式总结
startProcessLocked方式启动
- activity组件：ActivityStackSupervisor::startSpecificActivityLocked()
- service组件：ActiveServices::bringUpServiceLocked()
- ContentProvider组件：ActivityManagerService::getContentProviderImpl()
- 广播接收器组件：BroadcastQueue::processNextBroadcast()
- backup组件：ActivityManagerService::bindBackupAgent()
- AMS addAppLocked