/*
|
* Copyright (C) 2016 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License
|
*/
|
|
package com.android.server.am;
|
|
import static android.app.ActivityTaskManager.INVALID_TASK_ID;
|
import static android.content.pm.ApplicationInfo.FLAG_SYSTEM;
|
|
import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
|
import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME;
|
import static com.android.server.am.ActivityManagerService.MY_PID;
|
import static com.android.server.am.ActivityManagerService.SYSTEM_DEBUGGABLE;
|
import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_FREE_RESIZE;
|
import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_NONE;
|
|
import android.app.ActivityManager;
|
import android.app.ActivityOptions;
|
import android.app.ApplicationErrorReport;
|
import android.app.Dialog;
|
import android.content.ActivityNotFoundException;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.pm.ApplicationInfo;
|
import android.content.pm.ModuleInfo;
|
import android.content.pm.PackageManager;
|
import android.content.pm.VersionedPackage;
|
import android.net.Uri;
|
import android.os.Binder;
|
import android.os.Message;
|
import android.os.Process;
|
import android.os.SystemClock;
|
import android.os.SystemProperties;
|
import android.os.UserHandle;
|
import android.provider.Settings;
|
import android.util.ArrayMap;
|
import android.util.ArraySet;
|
import android.util.EventLog;
|
import android.util.Slog;
|
import android.util.SparseArray;
|
import android.util.TimeUtils;
|
import android.util.proto.ProtoOutputStream;
|
|
import com.android.internal.app.ProcessMap;
|
import com.android.internal.logging.MetricsLogger;
|
import com.android.internal.logging.nano.MetricsProto;
|
import com.android.server.PackageWatchdog;
|
import com.android.server.RescueParty;
|
import com.android.server.wm.WindowProcessController;
|
|
import java.io.FileDescriptor;
|
import java.io.PrintWriter;
|
import java.util.Collections;
|
import java.util.List;
|
|
/**
|
* Controls error conditions in applications.
|
*/
|
class AppErrors {
|
|
private static final String TAG = TAG_WITH_CLASS_NAME ? "AppErrors" : TAG_AM;
|
|
private final ActivityManagerService mService;
|
private final Context mContext;
|
private final PackageWatchdog mPackageWatchdog;
|
|
private ArraySet<String> mAppsNotReportingCrashes;
|
|
/**
|
* The last time that various processes have crashed since they were last explicitly started.
|
*/
|
private final ProcessMap<Long> mProcessCrashTimes = new ProcessMap<>();
|
|
/**
|
* The last time that various processes have crashed (not reset even when explicitly started).
|
*/
|
private final ProcessMap<Long> mProcessCrashTimesPersistent = new ProcessMap<>();
|
|
/**
|
* Set of applications that we consider to be bad, and will reject
|
* incoming broadcasts from (which the user has no control over).
|
* Processes are added to this set when they have crashed twice within
|
* a minimum amount of time; they are removed from it when they are
|
* later restarted (hopefully due to some user action). The value is the
|
* time it was added to the list.
|
*/
|
private final ProcessMap<BadProcessInfo> mBadProcesses = new ProcessMap<>();
|
|
|
AppErrors(Context context, ActivityManagerService service, PackageWatchdog watchdog) {
|
context.assertRuntimeOverlayThemable();
|
mService = service;
|
mContext = context;
|
mPackageWatchdog = watchdog;
|
}
|
|
void writeToProto(ProtoOutputStream proto, long fieldId, String dumpPackage) {
|
if (mProcessCrashTimes.getMap().isEmpty() && mBadProcesses.getMap().isEmpty()) {
|
return;
|
}
|
|
final long token = proto.start(fieldId);
|
final long now = SystemClock.uptimeMillis();
|
proto.write(AppErrorsProto.NOW_UPTIME_MS, now);
|
|
if (!mProcessCrashTimes.getMap().isEmpty()) {
|
final ArrayMap<String, SparseArray<Long>> pmap = mProcessCrashTimes.getMap();
|
final int procCount = pmap.size();
|
for (int ip = 0; ip < procCount; ip++) {
|
final long ctoken = proto.start(AppErrorsProto.PROCESS_CRASH_TIMES);
|
final String pname = pmap.keyAt(ip);
|
final SparseArray<Long> uids = pmap.valueAt(ip);
|
final int uidCount = uids.size();
|
|
proto.write(AppErrorsProto.ProcessCrashTime.PROCESS_NAME, pname);
|
for (int i = 0; i < uidCount; i++) {
|
final int puid = uids.keyAt(i);
|
final ProcessRecord r = mService.getProcessNames().get(pname, puid);
|
if (dumpPackage != null && (r == null || !r.pkgList.containsKey(dumpPackage))) {
|
continue;
|
}
|
final long etoken = proto.start(AppErrorsProto.ProcessCrashTime.ENTRIES);
|
proto.write(AppErrorsProto.ProcessCrashTime.Entry.UID, puid);
|
proto.write(AppErrorsProto.ProcessCrashTime.Entry.LAST_CRASHED_AT_MS,
|
uids.valueAt(i));
|
proto.end(etoken);
|
}
|
proto.end(ctoken);
|
}
|
|
}
|
|
if (!mBadProcesses.getMap().isEmpty()) {
|
final ArrayMap<String, SparseArray<BadProcessInfo>> pmap = mBadProcesses.getMap();
|
final int processCount = pmap.size();
|
for (int ip = 0; ip < processCount; ip++) {
|
final long btoken = proto.start(AppErrorsProto.BAD_PROCESSES);
|
final String pname = pmap.keyAt(ip);
|
final SparseArray<BadProcessInfo> uids = pmap.valueAt(ip);
|
final int uidCount = uids.size();
|
|
proto.write(AppErrorsProto.BadProcess.PROCESS_NAME, pname);
|
for (int i = 0; i < uidCount; i++) {
|
final int puid = uids.keyAt(i);
|
final ProcessRecord r = mService.getProcessNames().get(pname, puid);
|
if (dumpPackage != null && (r == null
|
|| !r.pkgList.containsKey(dumpPackage))) {
|
continue;
|
}
|
final BadProcessInfo info = uids.valueAt(i);
|
final long etoken = proto.start(AppErrorsProto.BadProcess.ENTRIES);
|
proto.write(AppErrorsProto.BadProcess.Entry.UID, puid);
|
proto.write(AppErrorsProto.BadProcess.Entry.CRASHED_AT_MS, info.time);
|
proto.write(AppErrorsProto.BadProcess.Entry.SHORT_MSG, info.shortMsg);
|
proto.write(AppErrorsProto.BadProcess.Entry.LONG_MSG, info.longMsg);
|
proto.write(AppErrorsProto.BadProcess.Entry.STACK, info.stack);
|
proto.end(etoken);
|
}
|
proto.end(btoken);
|
}
|
}
|
|
proto.end(token);
|
}
|
|
boolean dumpLocked(FileDescriptor fd, PrintWriter pw, boolean needSep, String dumpPackage) {
|
if (!mProcessCrashTimes.getMap().isEmpty()) {
|
boolean printed = false;
|
final long now = SystemClock.uptimeMillis();
|
final ArrayMap<String, SparseArray<Long>> pmap = mProcessCrashTimes.getMap();
|
final int processCount = pmap.size();
|
for (int ip = 0; ip < processCount; ip++) {
|
final String pname = pmap.keyAt(ip);
|
final SparseArray<Long> uids = pmap.valueAt(ip);
|
final int uidCount = uids.size();
|
for (int i = 0; i < uidCount; i++) {
|
final int puid = uids.keyAt(i);
|
final ProcessRecord r = mService.getProcessNames().get(pname, puid);
|
if (dumpPackage != null && (r == null
|
|| !r.pkgList.containsKey(dumpPackage))) {
|
continue;
|
}
|
if (!printed) {
|
if (needSep) pw.println();
|
needSep = true;
|
pw.println(" Time since processes crashed:");
|
printed = true;
|
}
|
pw.print(" Process "); pw.print(pname);
|
pw.print(" uid "); pw.print(puid);
|
pw.print(": last crashed ");
|
TimeUtils.formatDuration(now-uids.valueAt(i), pw);
|
pw.println(" ago");
|
}
|
}
|
}
|
|
if (!mBadProcesses.getMap().isEmpty()) {
|
boolean printed = false;
|
final ArrayMap<String, SparseArray<BadProcessInfo>> pmap = mBadProcesses.getMap();
|
final int processCount = pmap.size();
|
for (int ip = 0; ip < processCount; ip++) {
|
final String pname = pmap.keyAt(ip);
|
final SparseArray<BadProcessInfo> uids = pmap.valueAt(ip);
|
final int uidCount = uids.size();
|
for (int i = 0; i < uidCount; i++) {
|
final int puid = uids.keyAt(i);
|
final ProcessRecord r = mService.getProcessNames().get(pname, puid);
|
if (dumpPackage != null && (r == null
|
|| !r.pkgList.containsKey(dumpPackage))) {
|
continue;
|
}
|
if (!printed) {
|
if (needSep) pw.println();
|
needSep = true;
|
pw.println(" Bad processes:");
|
printed = true;
|
}
|
final BadProcessInfo info = uids.valueAt(i);
|
pw.print(" Bad process "); pw.print(pname);
|
pw.print(" uid "); pw.print(puid);
|
pw.print(": crashed at time "); pw.println(info.time);
|
if (info.shortMsg != null) {
|
pw.print(" Short msg: "); pw.println(info.shortMsg);
|
}
|
if (info.longMsg != null) {
|
pw.print(" Long msg: "); pw.println(info.longMsg);
|
}
|
if (info.stack != null) {
|
pw.println(" Stack:");
|
int lastPos = 0;
|
for (int pos = 0; pos < info.stack.length(); pos++) {
|
if (info.stack.charAt(pos) == '\n') {
|
pw.print(" ");
|
pw.write(info.stack, lastPos, pos-lastPos);
|
pw.println();
|
lastPos = pos+1;
|
}
|
}
|
if (lastPos < info.stack.length()) {
|
pw.print(" ");
|
pw.write(info.stack, lastPos, info.stack.length()-lastPos);
|
pw.println();
|
}
|
}
|
}
|
}
|
}
|
return needSep;
|
}
|
|
boolean isBadProcessLocked(ApplicationInfo info) {
|
return mBadProcesses.get(info.processName, info.uid) != null;
|
}
|
|
void clearBadProcessLocked(ApplicationInfo info) {
|
mBadProcesses.remove(info.processName, info.uid);
|
}
|
|
void resetProcessCrashTimeLocked(ApplicationInfo info) {
|
mProcessCrashTimes.remove(info.processName, info.uid);
|
}
|
|
void resetProcessCrashTimeLocked(boolean resetEntireUser, int appId, int userId) {
|
final ArrayMap<String, SparseArray<Long>> pmap = mProcessCrashTimes.getMap();
|
for (int ip = pmap.size() - 1; ip >= 0; ip--) {
|
SparseArray<Long> ba = pmap.valueAt(ip);
|
for (int i = ba.size() - 1; i >= 0; i--) {
|
boolean remove = false;
|
final int entUid = ba.keyAt(i);
|
if (!resetEntireUser) {
|
if (userId == UserHandle.USER_ALL) {
|
if (UserHandle.getAppId(entUid) == appId) {
|
remove = true;
|
}
|
} else {
|
if (entUid == UserHandle.getUid(userId, appId)) {
|
remove = true;
|
}
|
}
|
} else if (UserHandle.getUserId(entUid) == userId) {
|
remove = true;
|
}
|
if (remove) {
|
ba.removeAt(i);
|
}
|
}
|
if (ba.size() == 0) {
|
pmap.removeAt(ip);
|
}
|
}
|
}
|
|
void loadAppsNotReportingCrashesFromConfigLocked(String appsNotReportingCrashesConfig) {
|
if (appsNotReportingCrashesConfig != null) {
|
final String[] split = appsNotReportingCrashesConfig.split(",");
|
if (split.length > 0) {
|
mAppsNotReportingCrashes = new ArraySet<>();
|
Collections.addAll(mAppsNotReportingCrashes, split);
|
}
|
}
|
}
|
|
void killAppAtUserRequestLocked(ProcessRecord app, Dialog fromDialog) {
|
if (app.anrDialog == fromDialog) {
|
app.anrDialog = null;
|
}
|
if (app.waitDialog == fromDialog) {
|
app.waitDialog = null;
|
}
|
killAppImmediateLocked(app, "user-terminated", "user request after error");
|
}
|
|
private void killAppImmediateLocked(ProcessRecord app, String reason, String killReason) {
|
app.setCrashing(false);
|
app.crashingReport = null;
|
app.setNotResponding(false);
|
app.notRespondingReport = null;
|
if (app.pid > 0 && app.pid != MY_PID) {
|
handleAppCrashLocked(app, reason,
|
null /*shortMsg*/, null /*longMsg*/, null /*stackTrace*/, null /*data*/);
|
app.kill(killReason, true);
|
}
|
}
|
|
/**
|
* Induce a crash in the given app.
|
*
|
* @param uid if nonnegative, the required matching uid of the target to crash
|
* @param initialPid fast-path match for the target to crash
|
* @param packageName fallback match if the stated pid is not found or doesn't match uid
|
* @param userId If nonnegative, required to identify a match by package name
|
* @param message
|
*/
|
void scheduleAppCrashLocked(int uid, int initialPid, String packageName, int userId,
|
String message, boolean force) {
|
ProcessRecord proc = null;
|
|
// Figure out which process to kill. We don't trust that initialPid
|
// still has any relation to current pids, so must scan through the
|
// list.
|
|
synchronized (mService.mPidsSelfLocked) {
|
for (int i=0; i<mService.mPidsSelfLocked.size(); i++) {
|
ProcessRecord p = mService.mPidsSelfLocked.valueAt(i);
|
if (uid >= 0 && p.uid != uid) {
|
continue;
|
}
|
if (p.pid == initialPid) {
|
proc = p;
|
break;
|
}
|
if (p.pkgList.containsKey(packageName)
|
&& (userId < 0 || p.userId == userId)) {
|
proc = p;
|
}
|
}
|
}
|
|
if (proc == null) {
|
Slog.w(TAG, "crashApplication: nothing for uid=" + uid
|
+ " initialPid=" + initialPid
|
+ " packageName=" + packageName
|
+ " userId=" + userId);
|
return;
|
}
|
|
proc.scheduleCrash(message);
|
if (force) {
|
// If the app is responsive, the scheduled crash will happen as expected
|
// and then the delayed summary kill will be a no-op.
|
final ProcessRecord p = proc;
|
mService.mHandler.postDelayed(
|
() -> {
|
synchronized (mService) {
|
killAppImmediateLocked(p, "forced", "killed for invalid state");
|
}
|
},
|
5000L);
|
}
|
}
|
|
/**
|
* Bring up the "unexpected error" dialog box for a crashing app.
|
* Deal with edge cases (intercepts from instrumented applications,
|
* ActivityController, error intent receivers, that sort of thing).
|
* @param r the application crashing
|
* @param crashInfo describing the failure
|
*/
|
void crashApplication(ProcessRecord r, ApplicationErrorReport.CrashInfo crashInfo) {
|
final int callingPid = Binder.getCallingPid();
|
final int callingUid = Binder.getCallingUid();
|
|
final long origId = Binder.clearCallingIdentity();
|
try {
|
crashApplicationInner(r, crashInfo, callingPid, callingUid);
|
} finally {
|
Binder.restoreCallingIdentity(origId);
|
}
|
}
|
|
void crashApplicationInner(ProcessRecord r, ApplicationErrorReport.CrashInfo crashInfo,
|
int callingPid, int callingUid) {
|
long timeMillis = System.currentTimeMillis();
|
String shortMsg = crashInfo.exceptionClassName;
|
String longMsg = crashInfo.exceptionMessage;
|
String stackTrace = crashInfo.stackTrace;
|
if (shortMsg != null && longMsg != null) {
|
longMsg = shortMsg + ": " + longMsg;
|
} else if (shortMsg != null) {
|
longMsg = shortMsg;
|
}
|
|
if (r != null) {
|
boolean isApexModule = false;
|
try {
|
for (String androidPackage : r.getPackageList()) {
|
ModuleInfo moduleInfo = mContext.getPackageManager().getModuleInfo(
|
androidPackage, /*flags=*/ 0);
|
if (moduleInfo != null) {
|
isApexModule = true;
|
break;
|
}
|
}
|
} catch (IllegalStateException | PackageManager.NameNotFoundException e) {
|
// Call to PackageManager#getModuleInfo() can result in NameNotFoundException or
|
// IllegalStateException. In case they are thrown, there isn't much we can do
|
// other than proceed with app crash handling.
|
}
|
|
if (r.isPersistent() || isApexModule) {
|
// If a persistent app or apex module is stuck in a crash loop, the device isn't
|
// very usable, so we want to consider sending out a rescue party.
|
RescueParty.noteAppCrash(mContext, r.uid);
|
}
|
|
mPackageWatchdog.onPackageFailure(r.getPackageListWithVersionCode());
|
}
|
|
final int relaunchReason = r != null
|
? r.getWindowProcessController().computeRelaunchReason() : RELAUNCH_REASON_NONE;
|
|
AppErrorResult result = new AppErrorResult();
|
int taskId;
|
synchronized (mService) {
|
/**
|
* If crash is handled by instance of {@link android.app.IActivityController},
|
* finish now and don't show the app error dialog.
|
*/
|
if (handleAppCrashInActivityController(r, crashInfo, shortMsg, longMsg, stackTrace,
|
timeMillis, callingPid, callingUid)) {
|
return;
|
}
|
|
// Suppress crash dialog if the process is being relaunched due to a crash during a free
|
// resize.
|
if (relaunchReason == RELAUNCH_REASON_FREE_RESIZE) {
|
return;
|
}
|
|
/**
|
* If this process was running instrumentation, finish now - it will be handled in
|
* {@link ActivityManagerService#handleAppDiedLocked}.
|
*/
|
if (r != null && r.getActiveInstrumentation() != null) {
|
return;
|
}
|
|
// Log crash in battery stats.
|
if (r != null) {
|
mService.mBatteryStatsService.noteProcessCrash(r.processName, r.uid);
|
}
|
|
AppErrorDialog.Data data = new AppErrorDialog.Data();
|
data.result = result;
|
data.proc = r;
|
|
// If we can't identify the process or it's already exceeded its crash quota,
|
// quit right away without showing a crash dialog.
|
if (r == null || !makeAppCrashingLocked(r, shortMsg, longMsg, stackTrace, data)) {
|
return;
|
}
|
|
final Message msg = Message.obtain();
|
msg.what = ActivityManagerService.SHOW_ERROR_UI_MSG;
|
|
taskId = data.taskId;
|
msg.obj = data;
|
mService.mUiHandler.sendMessage(msg);
|
}
|
|
int res = result.get();
|
|
Intent appErrorIntent = null;
|
MetricsLogger.action(mContext, MetricsProto.MetricsEvent.ACTION_APP_CRASH, res);
|
if (res == AppErrorDialog.TIMEOUT || res == AppErrorDialog.CANCEL) {
|
res = AppErrorDialog.FORCE_QUIT;
|
}
|
synchronized (mService) {
|
if (res == AppErrorDialog.MUTE) {
|
stopReportingCrashesLocked(r);
|
}
|
if (res == AppErrorDialog.RESTART) {
|
mService.mProcessList.removeProcessLocked(r, false, true, "crash");
|
if (taskId != INVALID_TASK_ID) {
|
try {
|
mService.startActivityFromRecents(taskId,
|
ActivityOptions.makeBasic().toBundle());
|
} catch (IllegalArgumentException e) {
|
// Hmm...that didn't work. Task should either be in recents or associated
|
// with a stack.
|
Slog.e(TAG, "Could not restart taskId=" + taskId, e);
|
}
|
}
|
}
|
if (res == AppErrorDialog.FORCE_QUIT) {
|
long orig = Binder.clearCallingIdentity();
|
try {
|
// Kill it with fire!
|
mService.mAtmInternal.onHandleAppCrash(r.getWindowProcessController());
|
if (!r.isPersistent()) {
|
mService.mProcessList.removeProcessLocked(r, false, false, "crash");
|
mService.mAtmInternal.resumeTopActivities(false /* scheduleIdle */);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(orig);
|
}
|
}
|
if (res == AppErrorDialog.APP_INFO) {
|
appErrorIntent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
|
appErrorIntent.setData(Uri.parse("package:" + r.info.packageName));
|
appErrorIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
}
|
if (res == AppErrorDialog.FORCE_QUIT_AND_REPORT) {
|
appErrorIntent = createAppErrorIntentLocked(r, timeMillis, crashInfo);
|
}
|
if (r != null && !r.isolated && res != AppErrorDialog.RESTART) {
|
// XXX Can't keep track of crash time for isolated processes,
|
// since they don't have a persistent identity.
|
mProcessCrashTimes.put(r.info.processName, r.uid,
|
SystemClock.uptimeMillis());
|
}
|
}
|
|
if (appErrorIntent != null) {
|
try {
|
mContext.startActivityAsUser(appErrorIntent, new UserHandle(r.userId));
|
} catch (ActivityNotFoundException e) {
|
Slog.w(TAG, "bug report receiver dissappeared", e);
|
}
|
}
|
}
|
|
private boolean handleAppCrashInActivityController(ProcessRecord r,
|
ApplicationErrorReport.CrashInfo crashInfo,
|
String shortMsg, String longMsg,
|
String stackTrace, long timeMillis,
|
int callingPid, int callingUid) {
|
String name = r != null ? r.processName : null;
|
int pid = r != null ? r.pid : callingPid;
|
int uid = r != null ? r.info.uid : callingUid;
|
|
return mService.mAtmInternal.handleAppCrashInActivityController(
|
name, pid, shortMsg, longMsg, timeMillis, crashInfo.stackTrace, () -> {
|
if ("1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0"))
|
&& "Native crash".equals(crashInfo.exceptionClassName)) {
|
Slog.w(TAG, "Skip killing native crashed app " + name
|
+ "(" + pid + ") during testing");
|
} else {
|
Slog.w(TAG, "Force-killing crashed app " + name + " at watcher's request");
|
if (r != null) {
|
if (!makeAppCrashingLocked(r, shortMsg, longMsg, stackTrace, null)) {
|
r.kill("crash", true);
|
}
|
} else {
|
// Huh.
|
Process.killProcess(pid);
|
ProcessList.killProcessGroup(uid, pid);
|
}
|
}
|
});
|
}
|
|
private boolean makeAppCrashingLocked(ProcessRecord app,
|
String shortMsg, String longMsg, String stackTrace, AppErrorDialog.Data data) {
|
app.setCrashing(true);
|
app.crashingReport = generateProcessError(app,
|
ActivityManager.ProcessErrorStateInfo.CRASHED, null, shortMsg, longMsg, stackTrace);
|
app.startAppProblemLocked();
|
app.getWindowProcessController().stopFreezingActivities();
|
return handleAppCrashLocked(app, "force-crash" /*reason*/, shortMsg, longMsg, stackTrace,
|
data);
|
}
|
|
/**
|
* Generate a process error record, suitable for attachment to a ProcessRecord.
|
*
|
* @param app The ProcessRecord in which the error occurred.
|
* @param condition Crashing, Application Not Responding, etc. Values are defined in
|
* ActivityManager.ProcessErrorStateInfo
|
* @param activity The activity associated with the crash, if known.
|
* @param shortMsg Short message describing the crash.
|
* @param longMsg Long message describing the crash.
|
* @param stackTrace Full crash stack trace, may be null.
|
*
|
* @return Returns a fully-formed ProcessErrorStateInfo record.
|
*/
|
ActivityManager.ProcessErrorStateInfo generateProcessError(ProcessRecord app,
|
int condition, String activity, String shortMsg, String longMsg, String stackTrace) {
|
ActivityManager.ProcessErrorStateInfo report = new ActivityManager.ProcessErrorStateInfo();
|
|
report.condition = condition;
|
report.processName = app.processName;
|
report.pid = app.pid;
|
report.uid = app.info.uid;
|
report.tag = activity;
|
report.shortMsg = shortMsg;
|
report.longMsg = longMsg;
|
report.stackTrace = stackTrace;
|
|
return report;
|
}
|
|
Intent createAppErrorIntentLocked(ProcessRecord r,
|
long timeMillis, ApplicationErrorReport.CrashInfo crashInfo) {
|
ApplicationErrorReport report = createAppErrorReportLocked(r, timeMillis, crashInfo);
|
if (report == null) {
|
return null;
|
}
|
Intent result = new Intent(Intent.ACTION_APP_ERROR);
|
result.setComponent(r.errorReportReceiver);
|
result.putExtra(Intent.EXTRA_BUG_REPORT, report);
|
result.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
return result;
|
}
|
|
private ApplicationErrorReport createAppErrorReportLocked(ProcessRecord r,
|
long timeMillis, ApplicationErrorReport.CrashInfo crashInfo) {
|
if (r.errorReportReceiver == null) {
|
return null;
|
}
|
|
if (!r.isCrashing() && !r.isNotResponding() && !r.forceCrashReport) {
|
return null;
|
}
|
|
ApplicationErrorReport report = new ApplicationErrorReport();
|
report.packageName = r.info.packageName;
|
report.installerPackageName = r.errorReportReceiver.getPackageName();
|
report.processName = r.processName;
|
report.time = timeMillis;
|
report.systemApp = (r.info.flags & FLAG_SYSTEM) != 0;
|
|
if (r.isCrashing() || r.forceCrashReport) {
|
report.type = ApplicationErrorReport.TYPE_CRASH;
|
report.crashInfo = crashInfo;
|
} else if (r.isNotResponding()) {
|
report.type = ApplicationErrorReport.TYPE_ANR;
|
report.anrInfo = new ApplicationErrorReport.AnrInfo();
|
|
report.anrInfo.activity = r.notRespondingReport.tag;
|
report.anrInfo.cause = r.notRespondingReport.shortMsg;
|
report.anrInfo.info = r.notRespondingReport.longMsg;
|
}
|
|
return report;
|
}
|
|
boolean handleAppCrashLocked(ProcessRecord app, String reason,
|
String shortMsg, String longMsg, String stackTrace, AppErrorDialog.Data data) {
|
final long now = SystemClock.uptimeMillis();
|
final boolean showBackground = Settings.Secure.getInt(mContext.getContentResolver(),
|
Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0;
|
|
final boolean procIsBoundForeground =
|
(app.getCurProcState() == ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
|
|
Long crashTime;
|
Long crashTimePersistent;
|
boolean tryAgain = false;
|
|
if (!app.isolated) {
|
crashTime = mProcessCrashTimes.get(app.info.processName, app.uid);
|
crashTimePersistent = mProcessCrashTimesPersistent.get(app.info.processName, app.uid);
|
} else {
|
crashTime = crashTimePersistent = null;
|
}
|
|
// Bump up the crash count of any services currently running in the proc.
|
for (int i = app.services.size() - 1; i >= 0; i--) {
|
// Any services running in the application need to be placed
|
// back in the pending list.
|
ServiceRecord sr = app.services.valueAt(i);
|
// If the service was restarted a while ago, then reset crash count, else increment it.
|
if (now > sr.restartTime + ProcessList.MIN_CRASH_INTERVAL) {
|
sr.crashCount = 1;
|
} else {
|
sr.crashCount++;
|
}
|
// Allow restarting for started or bound foreground services that are crashing.
|
// This includes wallpapers.
|
if (sr.crashCount < mService.mConstants.BOUND_SERVICE_MAX_CRASH_RETRY
|
&& (sr.isForeground || procIsBoundForeground)) {
|
tryAgain = true;
|
}
|
}
|
|
if (crashTime != null && now < crashTime + ProcessList.MIN_CRASH_INTERVAL) {
|
// The process crashed again very quickly. If it was a bound foreground service, let's
|
// try to restart again in a while, otherwise the process loses!
|
Slog.w(TAG, "Process " + app.info.processName
|
+ " has crashed too many times: killing!");
|
EventLog.writeEvent(EventLogTags.AM_PROCESS_CRASHED_TOO_MUCH,
|
app.userId, app.info.processName, app.uid);
|
mService.mAtmInternal.onHandleAppCrash(app.getWindowProcessController());
|
if (!app.isPersistent()) {
|
// We don't want to start this process again until the user
|
// explicitly does so... but for persistent process, we really
|
// need to keep it running. If a persistent process is actually
|
// repeatedly crashing, then badness for everyone.
|
EventLog.writeEvent(EventLogTags.AM_PROC_BAD, app.userId, app.uid,
|
app.info.processName);
|
if (!app.isolated) {
|
// XXX We don't have a way to mark isolated processes
|
// as bad, since they don't have a peristent identity.
|
mBadProcesses.put(app.info.processName, app.uid,
|
new BadProcessInfo(now, shortMsg, longMsg, stackTrace));
|
mProcessCrashTimes.remove(app.info.processName, app.uid);
|
}
|
app.bad = true;
|
app.removed = true;
|
// Don't let services in this process be restarted and potentially
|
// annoy the user repeatedly. Unless it is persistent, since those
|
// processes run critical code.
|
mService.mProcessList.removeProcessLocked(app, false, tryAgain, "crash");
|
mService.mAtmInternal.resumeTopActivities(false /* scheduleIdle */);
|
if (!showBackground) {
|
return false;
|
}
|
}
|
mService.mAtmInternal.resumeTopActivities(false /* scheduleIdle */);
|
} else {
|
final int affectedTaskId = mService.mAtmInternal.finishTopCrashedActivities(
|
app.getWindowProcessController(), reason);
|
if (data != null) {
|
data.taskId = affectedTaskId;
|
}
|
if (data != null && crashTimePersistent != null
|
&& now < crashTimePersistent + ProcessList.MIN_CRASH_INTERVAL) {
|
data.repeating = true;
|
}
|
}
|
|
if (data != null && tryAgain) {
|
data.isRestartableForService = true;
|
}
|
|
// If the crashing process is what we consider to be the "home process" and it has been
|
// replaced by a third-party app, clear the package preferred activities from packages
|
// with a home activity running in the process to prevent a repeatedly crashing app
|
// from blocking the user to manually clear the list.
|
final WindowProcessController proc = app.getWindowProcessController();
|
final WindowProcessController homeProc = mService.mAtmInternal.getHomeProcess();
|
if (proc == homeProc && proc.hasActivities()
|
&& (((ProcessRecord) homeProc.mOwner).info.flags & FLAG_SYSTEM) == 0) {
|
proc.clearPackagePreferredForHomeActivities();
|
}
|
|
if (!app.isolated) {
|
// XXX Can't keep track of crash times for isolated processes,
|
// because they don't have a persistent identity.
|
mProcessCrashTimes.put(app.info.processName, app.uid, now);
|
mProcessCrashTimesPersistent.put(app.info.processName, app.uid, now);
|
}
|
|
if (app.crashHandler != null) mService.mHandler.post(app.crashHandler);
|
return true;
|
}
|
|
void handleShowAppErrorUi(Message msg) {
|
AppErrorDialog.Data data = (AppErrorDialog.Data) msg.obj;
|
boolean showBackground = Settings.Secure.getInt(mContext.getContentResolver(),
|
Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0;
|
|
AppErrorDialog dialogToShow = null;
|
final String packageName;
|
final int userId;
|
synchronized (mService) {
|
final ProcessRecord proc = data.proc;
|
final AppErrorResult res = data.result;
|
if (proc == null) {
|
Slog.e(TAG, "handleShowAppErrorUi: proc is null");
|
return;
|
}
|
packageName = proc.info.packageName;
|
userId = proc.userId;
|
if (proc.crashDialog != null) {
|
Slog.e(TAG, "App already has crash dialog: " + proc);
|
if (res != null) {
|
res.set(AppErrorDialog.ALREADY_SHOWING);
|
}
|
return;
|
}
|
boolean isBackground = (UserHandle.getAppId(proc.uid)
|
>= Process.FIRST_APPLICATION_UID
|
&& proc.pid != MY_PID);
|
for (int profileId : mService.mUserController.getCurrentProfileIds()) {
|
isBackground &= (userId != profileId);
|
}
|
if (isBackground && !showBackground) {
|
Slog.w(TAG, "Skipping crash dialog of " + proc + ": background");
|
if (res != null) {
|
res.set(AppErrorDialog.BACKGROUND_USER);
|
}
|
return;
|
}
|
final boolean showFirstCrash = Settings.Global.getInt(
|
mContext.getContentResolver(),
|
Settings.Global.SHOW_FIRST_CRASH_DIALOG, 0) != 0;
|
final boolean showFirstCrashDevOption = Settings.Secure.getIntForUser(
|
mContext.getContentResolver(),
|
Settings.Secure.SHOW_FIRST_CRASH_DIALOG_DEV_OPTION,
|
0,
|
mService.mUserController.getCurrentUserId()) != 0;
|
final boolean crashSilenced = mAppsNotReportingCrashes != null &&
|
mAppsNotReportingCrashes.contains(proc.info.packageName);
|
if ((mService.mAtmInternal.canShowErrorDialogs() || showBackground)
|
&& !crashSilenced
|
&& (showFirstCrash || showFirstCrashDevOption || data.repeating)) {
|
proc.crashDialog = dialogToShow = new AppErrorDialog(mContext, mService, data);
|
} else {
|
// The device is asleep, so just pretend that the user
|
// saw a crash dialog and hit "force quit".
|
if (res != null) {
|
res.set(AppErrorDialog.CANT_SHOW);
|
}
|
}
|
}
|
// If we've created a crash dialog, show it without the lock held
|
if (dialogToShow != null) {
|
Slog.i(TAG, "Showing crash dialog for package " + packageName + " u" + userId);
|
dialogToShow.show();
|
}
|
}
|
|
private void stopReportingCrashesLocked(ProcessRecord proc) {
|
if (mAppsNotReportingCrashes == null) {
|
mAppsNotReportingCrashes = new ArraySet<>();
|
}
|
mAppsNotReportingCrashes.add(proc.info.packageName);
|
}
|
|
void handleShowAnrUi(Message msg) {
|
Dialog dialogToShow = null;
|
List<VersionedPackage> packageList = null;
|
synchronized (mService) {
|
AppNotRespondingDialog.Data data = (AppNotRespondingDialog.Data) msg.obj;
|
final ProcessRecord proc = data.proc;
|
if (proc == null) {
|
Slog.e(TAG, "handleShowAnrUi: proc is null");
|
return;
|
}
|
if (!proc.isPersistent()) {
|
packageList = proc.getPackageListWithVersionCode();
|
}
|
if (proc.anrDialog != null) {
|
Slog.e(TAG, "App already has anr dialog: " + proc);
|
MetricsLogger.action(mContext, MetricsProto.MetricsEvent.ACTION_APP_ANR,
|
AppNotRespondingDialog.ALREADY_SHOWING);
|
return;
|
}
|
|
boolean showBackground = Settings.Secure.getInt(mContext.getContentResolver(),
|
Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0;
|
if (mService.mAtmInternal.canShowErrorDialogs() || showBackground) {
|
dialogToShow = new AppNotRespondingDialog(mService, mContext, data);
|
proc.anrDialog = dialogToShow;
|
} else {
|
MetricsLogger.action(mContext, MetricsProto.MetricsEvent.ACTION_APP_ANR,
|
AppNotRespondingDialog.CANT_SHOW);
|
// Just kill the app if there is no dialog to be shown.
|
mService.killAppAtUsersRequest(proc, null);
|
}
|
}
|
// If we've created a crash dialog, show it without the lock held
|
if (dialogToShow != null) {
|
dialogToShow.show();
|
}
|
// Notify PackageWatchdog without the lock held
|
if (packageList != null) {
|
mPackageWatchdog.onPackageFailure(packageList);
|
}
|
}
|
|
/**
|
* Information about a process that is currently marked as bad.
|
*/
|
static final class BadProcessInfo {
|
BadProcessInfo(long time, String shortMsg, String longMsg, String stack) {
|
this.time = time;
|
this.shortMsg = shortMsg;
|
this.longMsg = longMsg;
|
this.stack = stack;
|
}
|
|
final long time;
|
final String shortMsg;
|
final String longMsg;
|
final String stack;
|
}
|
|
}
|
