Improve handling of accessing dying provider. (ea69b566) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/am/ActivityManagerService.java

+29 −26

Original line number	Diff line number	Diff line
		@@ -9678,6 +9678,7 @@ public final class ActivityManagerService extends ActivityManagerNative

		checkTime(startTime, "getContentProviderImpl: incProviderCountLocked");

		boolean importantCaller = false;
		// In this case the provider instance already exists, so we can
		// return it right away.
		conn = incProviderCountLocked(r, cpr, token, stable);
		@@ -9687,6 +9688,7 @@ public final class ActivityManagerService extends ActivityManagerNative
		// make sure to count it as being accessed and thus
		// back up on the LRU list. This is good because
		// content providers are often expensive to start.
		importantCaller = true;
		checkTime(startTime, "getContentProviderImpl: before updateLruProcess");
		updateLruProcessLocked(cpr.proc, false, null);
		checkTime(startTime, "getContentProviderImpl: after updateLruProcess");
		@@ -9699,36 +9701,37 @@ public final class ActivityManagerService extends ActivityManagerNative
		"com.android.providers.calendar/.CalendarProvider2")) {
		Slog.v(TAG, "****************** KILLING "
		+ cpr.name.flattenToShortString());
		Process.killProcess(cpr.proc.pid);
		cpr.proc.kill("test killing calendar provider", true);
		}
		}

		boolean success = !cpr.proc.killedByAm;
		if (success) {
		checkTime(startTime, "getContentProviderImpl: before updateOomAdj");
		boolean success = updateOomAdjLocked(cpr.proc);
		success = updateOomAdjLocked(cpr.proc);
		maybeUpdateProviderUsageStatsLocked(r, cpr.info.packageName, name);
		checkTime(startTime, "getContentProviderImpl: after updateOomAdj");
		if (DEBUG_PROVIDER) Slog.i(TAG_PROVIDER, "Adjust success: " + success);
		// NOTE: there is still a race here where a signal could be
		// pending on the process even though we managed to update its
		// adj level. Not sure what to do about this, but at least
		// the race is now smaller.
		}

		// There is still a race here where a signal could be pending on
		// the process even though we managed to update its adj level.
		// We check this case for perceptible app but exclude persistent
		// because it should not be killed normally.
		if (success && importantCaller && r != null && !r.persistent
		&& r.pid != cpr.proc.pid && !cpr.proc.persistent) {
		success = ProcessList.isAlive(cpr.proc.pid, true);
		}

		if (!success) {
		// Uh oh... it looks like the provider's process
		// has been killed on us. We need to wait for a new
		// process to be started, and make sure its death
		// doesn't kill our process.
		// It looks like the provider's process has been killed.
		// We need to wait for a new process to be started,
		// and make sure its death doesn't kill caller process.
		Slog.i(TAG, "Existing provider " + cpr.name.flattenToShortString()
		+ " is crashing; detaching " + r);
		boolean lastRef = decProviderCountLocked(conn, cpr, token, stable);
		checkTime(startTime, "getContentProviderImpl: before appDied");
		appDiedLocked(cpr.proc);
		checkTime(startTime, "getContentProviderImpl: after appDied");
		if (!lastRef) {
		// This wasn't the last ref our process had on
		// the provider... we have now been killed, bail.
		return null;
		}
		providerRunning = false;
		conn = null;
		+ " is gone; waiting it to restart for " + r);
		cpr.provider = null;
		cpr.launchingApp = cpr.proc;
		mLaunchingProviders.add(cpr);
		}
		}

services/core/java/com/android/server/am/ProcessList.java

+57 −7

Original line number	Diff line number	Diff line
		@@ -720,7 +720,6 @@ final class ProcessList {
		}

		private static void writeLmkd(ByteBuffer buf) {

		for (int i = 0; i < 3; i++) {
		if (sLmkdSocket == null) {
		if (openLmkdSocket() == false) {
		@@ -747,4 +746,55 @@ final class ProcessList {
		}
		}
		}

		private static final int[] PROCESS_STATS_FORMAT;
		static {
		PROCESS_STATS_FORMAT = new int[31];
		java.util.Arrays.fill(PROCESS_STATS_FORMAT, android.os.Process.PROC_SPACE_TERM);
		// Process name enclosed in parentheses
		PROCESS_STATS_FORMAT[1] \|= android.os.Process.PROC_PARENS;
		// Process state (D/R/S/T/Z)
		PROCESS_STATS_FORMAT[2] \|= android.os.Process.PROC_OUT_STRING;
		// Bit mask of pending signals
		PROCESS_STATS_FORMAT[30] \|= android.os.Process.PROC_OUT_STRING;
		}

		static boolean isAlive(int pid, boolean noisy) {
		final String[] procStats = new String[2];
		final String stat = "/proc/" + pid + "/stat";
		if (android.os.Process.readProcFile(stat, PROCESS_STATS_FORMAT,
		procStats, null, null)) {
		if ("Z".equals(procStats[0])) {
		if (noisy) {
		Slog.i(TAG, pid + " is zombie state");
		}
		return false;
		}
		try {
		int pendingSignals = Integer.parseInt(procStats[1]);
		if ((pendingSignals & (1 << 8)) != 0) {
		if (noisy) {
		Slog.i(TAG, pid + " has pending signal 9");
		}
		return false;
		}
		} catch (NumberFormatException e) {
		Slog.w(TAG, "Unknown pending signals " + procStats[1] + " of " + pid);
		}
		} else {
		boolean exists = false;
		try {
		exists = libcore.io.Libcore.os.access(stat, android.system.OsConstants.F_OK);
		} catch (android.system.ErrnoException e) {
		exists = e.errno != android.system.OsConstants.ENOENT;
		}
		if (!exists) {
		if (noisy) {
		Slog.i(TAG, stat + " does not exist");
		}
		return false;
		}
		}
		return true;
		}
		}