1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License 15 */ 16 17 package com.android.server.am; 18 19 import com.android.internal.app.ProcessMap; 20 import com.android.internal.logging.MetricsLogger; 21 import com.android.internal.logging.MetricsProto; 22 import com.android.internal.os.ProcessCpuTracker; 23 import com.android.server.Watchdog; 24 25 import android.app.Activity; 26 import android.app.ActivityManager; 27 import android.app.ActivityOptions; 28 import android.app.ActivityThread; 29 import android.app.AppOpsManager; 30 import android.app.ApplicationErrorReport; 31 import android.app.Dialog; 32 import android.content.ActivityNotFoundException; 33 import android.content.Context; 34 import android.content.Intent; 35 import android.content.pm.ApplicationInfo; 36 import android.content.pm.IPackageDataObserver; 37 import android.content.pm.PackageManager; 38 import android.os.Binder; 39 import android.os.Bundle; 40 import android.os.Message; 41 import android.os.Process; 42 import android.os.RemoteException; 43 import android.os.SystemClock; 44 import android.os.SystemProperties; 45 import android.os.UserHandle; 46 import android.provider.Settings; 47 import android.util.ArrayMap; 48 import android.util.ArraySet; 49 import android.util.EventLog; 50 import android.util.Log; 51 import android.util.Slog; 52 import android.util.SparseArray; 53 import android.util.TimeUtils; 54 55 import java.io.File; 56 import java.io.FileDescriptor; 57 import java.io.PrintWriter; 58 import java.util.ArrayList; 59 import java.util.Collections; 60 import java.util.HashMap; 61 import java.util.concurrent.Semaphore; 62 63 import static com.android.server.Watchdog.NATIVE_STACKS_OF_INTEREST; 64 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_ANR; 65 import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM; 66 import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME; 67 import static com.android.server.am.ActivityManagerService.MY_PID; 68 import static com.android.server.am.ActivityManagerService.SYSTEM_DEBUGGABLE; 69 70 /** 71 * Controls error conditions in applications. 72 */ 73 class AppErrors { 74 75 private static final String TAG = TAG_WITH_CLASS_NAME ? "AppErrors" : TAG_AM; 76 77 private final ActivityManagerService mService; 78 private final Context mContext; 79 80 private ArraySet<String> mAppsNotReportingCrashes; 81 82 /** 83 * The last time that various processes have crashed since they were last explicitly started. 84 */ 85 private final ProcessMap<Long> mProcessCrashTimes = new ProcessMap<>(); 86 87 /** 88 * The last time that various processes have crashed (not reset even when explicitly started). 89 */ 90 private final ProcessMap<Long> mProcessCrashTimesPersistent = new ProcessMap<>(); 91 92 /** 93 * Set of applications that we consider to be bad, and will reject 94 * incoming broadcasts from (which the user has no control over). 95 * Processes are added to this set when they have crashed twice within 96 * a minimum amount of time; they are removed from it when they are 97 * later restarted (hopefully due to some user action). The value is the 98 * time it was added to the list. 99 */ 100 private final ProcessMap<BadProcessInfo> mBadProcesses = new ProcessMap<>(); 101 102 103 AppErrors(Context context, ActivityManagerService service) { 104 mService = service; 105 mContext = context; 106 } 107 108 boolean dumpLocked(FileDescriptor fd, PrintWriter pw, boolean needSep, 109 String dumpPackage) { 110 if (!mProcessCrashTimes.getMap().isEmpty()) { 111 boolean printed = false; 112 final long now = SystemClock.uptimeMillis(); 113 final ArrayMap<String, SparseArray<Long>> pmap = mProcessCrashTimes.getMap(); 114 final int processCount = pmap.size(); 115 for (int ip = 0; ip < processCount; ip++) { 116 final String pname = pmap.keyAt(ip); 117 final SparseArray<Long> uids = pmap.valueAt(ip); 118 final int uidCount = uids.size(); 119 for (int i = 0; i < uidCount; i++) { 120 final int puid = uids.keyAt(i); 121 final ProcessRecord r = mService.mProcessNames.get(pname, puid); 122 if (dumpPackage != null && (r == null 123 || !r.pkgList.containsKey(dumpPackage))) { 124 continue; 125 } 126 if (!printed) { 127 if (needSep) pw.println(); 128 needSep = true; 129 pw.println(" Time since processes crashed:"); 130 printed = true; 131 } 132 pw.print(" Process "); pw.print(pname); 133 pw.print(" uid "); pw.print(puid); 134 pw.print(": last crashed "); 135 TimeUtils.formatDuration(now-uids.valueAt(i), pw); 136 pw.println(" ago"); 137 } 138 } 139 } 140 141 if (!mBadProcesses.getMap().isEmpty()) { 142 boolean printed = false; 143 final ArrayMap<String, SparseArray<BadProcessInfo>> pmap = mBadProcesses.getMap(); 144 final int processCount = pmap.size(); 145 for (int ip = 0; ip < processCount; ip++) { 146 final String pname = pmap.keyAt(ip); 147 final SparseArray<BadProcessInfo> uids = pmap.valueAt(ip); 148 final int uidCount = uids.size(); 149 for (int i = 0; i < uidCount; i++) { 150 final int puid = uids.keyAt(i); 151 final ProcessRecord r = mService.mProcessNames.get(pname, puid); 152 if (dumpPackage != null && (r == null 153 || !r.pkgList.containsKey(dumpPackage))) { 154 continue; 155 } 156 if (!printed) { 157 if (needSep) pw.println(); 158 needSep = true; 159 pw.println(" Bad processes:"); 160 printed = true; 161 } 162 final BadProcessInfo info = uids.valueAt(i); 163 pw.print(" Bad process "); pw.print(pname); 164 pw.print(" uid "); pw.print(puid); 165 pw.print(": crashed at time "); pw.println(info.time); 166 if (info.shortMsg != null) { 167 pw.print(" Short msg: "); pw.println(info.shortMsg); 168 } 169 if (info.longMsg != null) { 170 pw.print(" Long msg: "); pw.println(info.longMsg); 171 } 172 if (info.stack != null) { 173 pw.println(" Stack:"); 174 int lastPos = 0; 175 for (int pos = 0; pos < info.stack.length(); pos++) { 176 if (info.stack.charAt(pos) == '\n') { 177 pw.print(" "); 178 pw.write(info.stack, lastPos, pos-lastPos); 179 pw.println(); 180 lastPos = pos+1; 181 } 182 } 183 if (lastPos < info.stack.length()) { 184 pw.print(" "); 185 pw.write(info.stack, lastPos, info.stack.length()-lastPos); 186 pw.println(); 187 } 188 } 189 } 190 } 191 } 192 return needSep; 193 } 194 195 boolean isBadProcessLocked(ApplicationInfo info) { 196 return mBadProcesses.get(info.processName, info.uid) != null; 197 } 198 199 void clearBadProcessLocked(ApplicationInfo info) { 200 mBadProcesses.remove(info.processName, info.uid); 201 } 202 203 void resetProcessCrashTimeLocked(ApplicationInfo info) { 204 mProcessCrashTimes.remove(info.processName, info.uid); 205 } 206 207 void resetProcessCrashTimeLocked(boolean resetEntireUser, int appId, int userId) { 208 final ArrayMap<String, SparseArray<Long>> pmap = mProcessCrashTimes.getMap(); 209 for (int ip = pmap.size() - 1; ip >= 0; ip--) { 210 SparseArray<Long> ba = pmap.valueAt(ip); 211 for (int i = ba.size() - 1; i >= 0; i--) { 212 boolean remove = false; 213 final int entUid = ba.keyAt(i); 214 if (!resetEntireUser) { 215 if (userId == UserHandle.USER_ALL) { 216 if (UserHandle.getAppId(entUid) == appId) { 217 remove = true; 218 } 219 } else { 220 if (entUid == UserHandle.getUid(userId, appId)) { 221 remove = true; 222 } 223 } 224 } else if (UserHandle.getUserId(entUid) == userId) { 225 remove = true; 226 } 227 if (remove) { 228 ba.removeAt(i); 229 } 230 } 231 if (ba.size() == 0) { 232 pmap.removeAt(ip); 233 } 234 } 235 } 236 237 void loadAppsNotReportingCrashesFromConfigLocked(String appsNotReportingCrashesConfig) { 238 if (appsNotReportingCrashesConfig != null) { 239 final String[] split = appsNotReportingCrashesConfig.split(","); 240 if (split.length > 0) { 241 mAppsNotReportingCrashes = new ArraySet<>(); 242 Collections.addAll(mAppsNotReportingCrashes, split); 243 } 244 } 245 } 246 247 void killAppAtUserRequestLocked(ProcessRecord app, Dialog fromDialog) { 248 app.crashing = false; 249 app.crashingReport = null; 250 app.notResponding = false; 251 app.notRespondingReport = null; 252 if (app.anrDialog == fromDialog) { 253 app.anrDialog = null; 254 } 255 if (app.waitDialog == fromDialog) { 256 app.waitDialog = null; 257 } 258 if (app.pid > 0 && app.pid != MY_PID) { 259 handleAppCrashLocked(app, "user-terminated" /*reason*/, 260 null /*shortMsg*/, null /*longMsg*/, null /*stackTrace*/, null /*data*/); 261 app.kill("user request after error", true); 262 } 263 } 264 265 void scheduleAppCrashLocked(int uid, int initialPid, String packageName, 266 String message) { 267 ProcessRecord proc = null; 268 269 // Figure out which process to kill. We don't trust that initialPid 270 // still has any relation to current pids, so must scan through the 271 // list. 272 273 synchronized (mService.mPidsSelfLocked) { 274 for (int i=0; i<mService.mPidsSelfLocked.size(); i++) { 275 ProcessRecord p = mService.mPidsSelfLocked.valueAt(i); 276 if (p.uid != uid) { 277 continue; 278 } 279 if (p.pid == initialPid) { 280 proc = p; 281 break; 282 } 283 if (p.pkgList.containsKey(packageName)) { 284 proc = p; 285 } 286 } 287 } 288 289 if (proc == null) { 290 Slog.w(TAG, "crashApplication: nothing for uid=" + uid 291 + " initialPid=" + initialPid 292 + " packageName=" + packageName); 293 return; 294 } 295 296 proc.scheduleCrash(message); 297 } 298 299 /** 300 * Bring up the "unexpected error" dialog box for a crashing app. 301 * Deal with edge cases (intercepts from instrumented applications, 302 * ActivityController, error intent receivers, that sort of thing). 303 * @param r the application crashing 304 * @param crashInfo describing the failure 305 */ 306 void crashApplication(ProcessRecord r, ApplicationErrorReport.CrashInfo crashInfo) { 307 final long origId = Binder.clearCallingIdentity(); 308 try { 309 crashApplicationInner(r, crashInfo); 310 } finally { 311 Binder.restoreCallingIdentity(origId); 312 } 313 } 314 315 void crashApplicationInner(ProcessRecord r, ApplicationErrorReport.CrashInfo crashInfo) { 316 long timeMillis = System.currentTimeMillis(); 317 String shortMsg = crashInfo.exceptionClassName; 318 String longMsg = crashInfo.exceptionMessage; 319 String stackTrace = crashInfo.stackTrace; 320 if (shortMsg != null && longMsg != null) { 321 longMsg = shortMsg + ": " + longMsg; 322 } else if (shortMsg != null) { 323 longMsg = shortMsg; 324 } 325 326 AppErrorResult result = new AppErrorResult(); 327 TaskRecord task; 328 synchronized (mService) { 329 /** 330 * If crash is handled by instance of {@link android.app.IActivityController}, 331 * finish now and don't show the app error dialog. 332 */ 333 if (handleAppCrashInActivityController(r, crashInfo, shortMsg, longMsg, stackTrace, 334 timeMillis)) { 335 return; 336 } 337 338 /** 339 * If this process was running instrumentation, finish now - it will be handled in 340 * {@link ActivityManagerService#handleAppDiedLocked}. 341 */ 342 if (r != null && r.instrumentationClass != null) { 343 return; 344 } 345 346 // Log crash in battery stats. 347 if (r != null) { 348 mService.mBatteryStatsService.noteProcessCrash(r.processName, r.uid); 349 } 350 351 AppErrorDialog.Data data = new AppErrorDialog.Data(); 352 data.result = result; 353 data.proc = r; 354 355 // If we can't identify the process or it's already exceeded its crash quota, 356 // quit right away without showing a crash dialog. 357 if (r == null || !makeAppCrashingLocked(r, shortMsg, longMsg, stackTrace, data)) { 358 return; 359 } 360 361 Message msg = Message.obtain(); 362 msg.what = ActivityManagerService.SHOW_ERROR_UI_MSG; 363 364 task = data.task; 365 msg.obj = data; 366 mService.mUiHandler.sendMessage(msg); 367 } 368 369 int res = result.get(); 370 371 Intent appErrorIntent = null; 372 MetricsLogger.action(mContext, MetricsProto.MetricsEvent.ACTION_APP_CRASH, res); 373 if (res == AppErrorDialog.TIMEOUT || res == AppErrorDialog.CANCEL) { 374 res = AppErrorDialog.FORCE_QUIT; 375 } 376 synchronized (mService) { 377 if (res == AppErrorDialog.MUTE) { 378 stopReportingCrashesLocked(r); 379 } 380 if (res == AppErrorDialog.RESTART) { 381 mService.removeProcessLocked(r, false, true, "crash"); 382 if (task != null) { 383 try { 384 mService.startActivityFromRecents(task.taskId, 385 ActivityOptions.makeBasic().toBundle()); 386 } catch (IllegalArgumentException e) { 387 // Hmm, that didn't work, app might have crashed before creating a 388 // recents entry. Let's see if we have a safe-to-restart intent. 389 if (task.intent.getCategories().contains( 390 Intent.CATEGORY_LAUNCHER)) { 391 mService.startActivityInPackage(task.mCallingUid, 392 task.mCallingPackage, task.intent, 393 null, null, null, 0, 0, 394 ActivityOptions.makeBasic().toBundle(), 395 task.userId, null, null); 396 } 397 } 398 } 399 } 400 if (res == AppErrorDialog.FORCE_QUIT) { 401 long orig = Binder.clearCallingIdentity(); 402 try { 403 // Kill it with fire! 404 mService.mStackSupervisor.handleAppCrashLocked(r); 405 if (!r.persistent) { 406 mService.removeProcessLocked(r, false, false, "crash"); 407 mService.mStackSupervisor.resumeFocusedStackTopActivityLocked(); 408 } 409 } finally { 410 Binder.restoreCallingIdentity(orig); 411 } 412 } 413 if (res == AppErrorDialog.FORCE_QUIT_AND_REPORT) { 414 appErrorIntent = createAppErrorIntentLocked(r, timeMillis, crashInfo); 415 } 416 if (r != null && !r.isolated && res != AppErrorDialog.RESTART) { 417 // XXX Can't keep track of crash time for isolated processes, 418 // since they don't have a persistent identity. 419 mProcessCrashTimes.put(r.info.processName, r.uid, 420 SystemClock.uptimeMillis()); 421 } 422 } 423 424 if (appErrorIntent != null) { 425 try { 426 mContext.startActivityAsUser(appErrorIntent, new UserHandle(r.userId)); 427 } catch (ActivityNotFoundException e) { 428 Slog.w(TAG, "bug report receiver dissappeared", e); 429 } 430 } 431 } 432 433 private boolean handleAppCrashInActivityController(ProcessRecord r, 434 ApplicationErrorReport.CrashInfo crashInfo, 435 String shortMsg, String longMsg, 436 String stackTrace, long timeMillis) { 437 if (mService.mController == null) { 438 return false; 439 } 440 441 try { 442 String name = r != null ? r.processName : null; 443 int pid = r != null ? r.pid : Binder.getCallingPid(); 444 int uid = r != null ? r.info.uid : Binder.getCallingUid(); 445 if (!mService.mController.appCrashed(name, pid, 446 shortMsg, longMsg, timeMillis, crashInfo.stackTrace)) { 447 if ("1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0")) 448 && "Native crash".equals(crashInfo.exceptionClassName)) { 449 Slog.w(TAG, "Skip killing native crashed app " + name 450 + "(" + pid + ") during testing"); 451 } else { 452 Slog.w(TAG, "Force-killing crashed app " + name 453 + " at watcher's request"); 454 if (r != null) { 455 if (!makeAppCrashingLocked(r, shortMsg, longMsg, stackTrace, null)) 456 { 457 r.kill("crash", true); 458 } 459 } else { 460 // Huh. 461 Process.killProcess(pid); 462 ActivityManagerService.killProcessGroup(uid, pid); 463 } 464 } 465 return true; 466 } 467 } catch (RemoteException e) { 468 mService.mController = null; 469 Watchdog.getInstance().setActivityController(null); 470 } 471 return false; 472 } 473 474 private boolean makeAppCrashingLocked(ProcessRecord app, 475 String shortMsg, String longMsg, String stackTrace, AppErrorDialog.Data data) { 476 app.crashing = true; 477 app.crashingReport = generateProcessError(app, 478 ActivityManager.ProcessErrorStateInfo.CRASHED, null, shortMsg, longMsg, stackTrace); 479 startAppProblemLocked(app); 480 app.stopFreezingAllLocked(); 481 return handleAppCrashLocked(app, "force-crash" /*reason*/, shortMsg, longMsg, stackTrace, 482 data); 483 } 484 485 void startAppProblemLocked(ProcessRecord app) { 486 // If this app is not running under the current user, then we 487 // can't give it a report button because that would require 488 // launching the report UI under a different user. 489 app.errorReportReceiver = null; 490 491 for (int userId : mService.mUserController.getCurrentProfileIdsLocked()) { 492 if (app.userId == userId) { 493 app.errorReportReceiver = ApplicationErrorReport.getErrorReportReceiver( 494 mContext, app.info.packageName, app.info.flags); 495 } 496 } 497 mService.skipCurrentReceiverLocked(app); 498 } 499 500 /** 501 * Generate a process error record, suitable for attachment to a ProcessRecord. 502 * 503 * @param app The ProcessRecord in which the error occurred. 504 * @param condition Crashing, Application Not Responding, etc. Values are defined in 505 * ActivityManager.AppErrorStateInfo 506 * @param activity The activity associated with the crash, if known. 507 * @param shortMsg Short message describing the crash. 508 * @param longMsg Long message describing the crash. 509 * @param stackTrace Full crash stack trace, may be null. 510 * 511 * @return Returns a fully-formed AppErrorStateInfo record. 512 */ 513 private ActivityManager.ProcessErrorStateInfo generateProcessError(ProcessRecord app, 514 int condition, String activity, String shortMsg, String longMsg, String stackTrace) { 515 ActivityManager.ProcessErrorStateInfo report = new ActivityManager.ProcessErrorStateInfo(); 516 517 report.condition = condition; 518 report.processName = app.processName; 519 report.pid = app.pid; 520 report.uid = app.info.uid; 521 report.tag = activity; 522 report.shortMsg = shortMsg; 523 report.longMsg = longMsg; 524 report.stackTrace = stackTrace; 525 526 return report; 527 } 528 529 Intent createAppErrorIntentLocked(ProcessRecord r, 530 long timeMillis, ApplicationErrorReport.CrashInfo crashInfo) { 531 ApplicationErrorReport report = createAppErrorReportLocked(r, timeMillis, crashInfo); 532 if (report == null) { 533 return null; 534 } 535 Intent result = new Intent(Intent.ACTION_APP_ERROR); 536 result.setComponent(r.errorReportReceiver); 537 result.putExtra(Intent.EXTRA_BUG_REPORT, report); 538 result.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 539 return result; 540 } 541 542 private ApplicationErrorReport createAppErrorReportLocked(ProcessRecord r, 543 long timeMillis, ApplicationErrorReport.CrashInfo crashInfo) { 544 if (r.errorReportReceiver == null) { 545 return null; 546 } 547 548 if (!r.crashing && !r.notResponding && !r.forceCrashReport) { 549 return null; 550 } 551 552 ApplicationErrorReport report = new ApplicationErrorReport(); 553 report.packageName = r.info.packageName; 554 report.installerPackageName = r.errorReportReceiver.getPackageName(); 555 report.processName = r.processName; 556 report.time = timeMillis; 557 report.systemApp = (r.info.flags & ApplicationInfo.FLAG_SYSTEM) != 0; 558 559 if (r.crashing || r.forceCrashReport) { 560 report.type = ApplicationErrorReport.TYPE_CRASH; 561 report.crashInfo = crashInfo; 562 } else if (r.notResponding) { 563 report.type = ApplicationErrorReport.TYPE_ANR; 564 report.anrInfo = new ApplicationErrorReport.AnrInfo(); 565 566 report.anrInfo.activity = r.notRespondingReport.tag; 567 report.anrInfo.cause = r.notRespondingReport.shortMsg; 568 report.anrInfo.info = r.notRespondingReport.longMsg; 569 } 570 571 return report; 572 } 573 574 boolean handleAppCrashLocked(ProcessRecord app, String reason, 575 String shortMsg, String longMsg, String stackTrace, AppErrorDialog.Data data) { 576 long now = SystemClock.uptimeMillis(); 577 578 Long crashTime; 579 Long crashTimePersistent; 580 if (!app.isolated) { 581 crashTime = mProcessCrashTimes.get(app.info.processName, app.uid); 582 crashTimePersistent = mProcessCrashTimesPersistent.get(app.info.processName, app.uid); 583 } else { 584 crashTime = crashTimePersistent = null; 585 } 586 if (crashTime != null && now < crashTime+ProcessList.MIN_CRASH_INTERVAL) { 587 // This process loses! 588 Slog.w(TAG, "Process " + app.info.processName 589 + " has crashed too many times: killing!"); 590 EventLog.writeEvent(EventLogTags.AM_PROCESS_CRASHED_TOO_MUCH, 591 app.userId, app.info.processName, app.uid); 592 mService.mStackSupervisor.handleAppCrashLocked(app); 593 if (!app.persistent) { 594 // We don't want to start this process again until the user 595 // explicitly does so... but for persistent process, we really 596 // need to keep it running. If a persistent process is actually 597 // repeatedly crashing, then badness for everyone. 598 EventLog.writeEvent(EventLogTags.AM_PROC_BAD, app.userId, app.uid, 599 app.info.processName); 600 if (!app.isolated) { 601 // XXX We don't have a way to mark isolated processes 602 // as bad, since they don't have a peristent identity. 603 mBadProcesses.put(app.info.processName, app.uid, 604 new BadProcessInfo(now, shortMsg, longMsg, stackTrace)); 605 mProcessCrashTimes.remove(app.info.processName, app.uid); 606 } 607 app.bad = true; 608 app.removed = true; 609 // Don't let services in this process be restarted and potentially 610 // annoy the user repeatedly. Unless it is persistent, since those 611 // processes run critical code. 612 mService.removeProcessLocked(app, false, false, "crash"); 613 mService.mStackSupervisor.resumeFocusedStackTopActivityLocked(); 614 return false; 615 } 616 mService.mStackSupervisor.resumeFocusedStackTopActivityLocked(); 617 } else { 618 TaskRecord affectedTask = 619 mService.mStackSupervisor.finishTopRunningActivityLocked(app, reason); 620 if (data != null) { 621 data.task = affectedTask; 622 } 623 if (data != null && crashTimePersistent != null 624 && now < crashTimePersistent + ProcessList.MIN_CRASH_INTERVAL) { 625 data.repeating = true; 626 } 627 } 628 629 // Bump up the crash count of any services currently running in the proc. 630 for (int i=app.services.size()-1; i>=0; i--) { 631 // Any services running in the application need to be placed 632 // back in the pending list. 633 ServiceRecord sr = app.services.valueAt(i); 634 sr.crashCount++; 635 } 636 637 // If the crashing process is what we consider to be the "home process" and it has been 638 // replaced by a third-party app, clear the package preferred activities from packages 639 // with a home activity running in the process to prevent a repeatedly crashing app 640 // from blocking the user to manually clear the list. 641 final ArrayList<ActivityRecord> activities = app.activities; 642 if (app == mService.mHomeProcess && activities.size() > 0 643 && (mService.mHomeProcess.info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) { 644 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { 645 final ActivityRecord r = activities.get(activityNdx); 646 if (r.isHomeActivity()) { 647 Log.i(TAG, "Clearing package preferred activities from " + r.packageName); 648 try { 649 ActivityThread.getPackageManager() 650 .clearPackagePreferredActivities(r.packageName); 651 } catch (RemoteException c) { 652 // pm is in same process, this will never happen. 653 } 654 } 655 } 656 } 657 658 if (!app.isolated) { 659 // XXX Can't keep track of crash times for isolated processes, 660 // because they don't have a perisistent identity. 661 mProcessCrashTimes.put(app.info.processName, app.uid, now); 662 mProcessCrashTimesPersistent.put(app.info.processName, app.uid, now); 663 } 664 665 if (app.crashHandler != null) mService.mHandler.post(app.crashHandler); 666 return true; 667 } 668 669 void handleShowAppErrorUi(Message msg) { 670 AppErrorDialog.Data data = (AppErrorDialog.Data) msg.obj; 671 boolean showBackground = Settings.Secure.getInt(mContext.getContentResolver(), 672 Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0; 673 synchronized (mService) { 674 ProcessRecord proc = data.proc; 675 AppErrorResult res = data.result; 676 if (proc != null && proc.crashDialog != null) { 677 Slog.e(TAG, "App already has crash dialog: " + proc); 678 if (res != null) { 679 res.set(AppErrorDialog.ALREADY_SHOWING); 680 } 681 return; 682 } 683 boolean isBackground = (UserHandle.getAppId(proc.uid) 684 >= Process.FIRST_APPLICATION_UID 685 && proc.pid != MY_PID); 686 for (int userId : mService.mUserController.getCurrentProfileIdsLocked()) { 687 isBackground &= (proc.userId != userId); 688 } 689 if (isBackground && !showBackground) { 690 Slog.w(TAG, "Skipping crash dialog of " + proc + ": background"); 691 if (res != null) { 692 res.set(AppErrorDialog.BACKGROUND_USER); 693 } 694 return; 695 } 696 final boolean crashSilenced = mAppsNotReportingCrashes != null && 697 mAppsNotReportingCrashes.contains(proc.info.packageName); 698 if (mService.canShowErrorDialogs() && !crashSilenced) { 699 proc.crashDialog = new AppErrorDialog(mContext, mService, data); 700 } else { 701 // The device is asleep, so just pretend that the user 702 // saw a crash dialog and hit "force quit". 703 if (res != null) { 704 res.set(AppErrorDialog.CANT_SHOW); 705 } 706 } 707 } 708 // If we've created a crash dialog, show it without the lock held 709 if(data.proc.crashDialog != null) { 710 data.proc.crashDialog.show(); 711 } 712 } 713 714 void stopReportingCrashesLocked(ProcessRecord proc) { 715 if (mAppsNotReportingCrashes == null) { 716 mAppsNotReportingCrashes = new ArraySet<>(); 717 } 718 mAppsNotReportingCrashes.add(proc.info.packageName); 719 } 720 721 final void appNotResponding(ProcessRecord app, ActivityRecord activity, 722 ActivityRecord parent, boolean aboveSystem, final String annotation) { 723 ArrayList<Integer> firstPids = new ArrayList<Integer>(5); 724 SparseArray<Boolean> lastPids = new SparseArray<Boolean>(20); 725 726 if (mService.mController != null) { 727 try { 728 // 0 == continue, -1 = kill process immediately 729 int res = mService.mController.appEarlyNotResponding( 730 app.processName, app.pid, annotation); 731 if (res < 0 && app.pid != MY_PID) { 732 app.kill("anr", true); 733 } 734 } catch (RemoteException e) { 735 mService.mController = null; 736 Watchdog.getInstance().setActivityController(null); 737 } 738 } 739 740 long anrTime = SystemClock.uptimeMillis(); 741 if (ActivityManagerService.MONITOR_CPU_USAGE) { 742 mService.updateCpuStatsNow(); 743 } 744 745 // Unless configured otherwise, swallow ANRs in background processes & kill the process. 746 boolean showBackground = Settings.Secure.getInt(mContext.getContentResolver(), 747 Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0; 748 749 boolean isSilentANR; 750 751 synchronized (mService) { 752 // PowerManager.reboot() can block for a long time, so ignore ANRs while shutting down. 753 if (mService.mShuttingDown) { 754 Slog.i(TAG, "During shutdown skipping ANR: " + app + " " + annotation); 755 return; 756 } else if (app.notResponding) { 757 Slog.i(TAG, "Skipping duplicate ANR: " + app + " " + annotation); 758 return; 759 } else if (app.crashing) { 760 Slog.i(TAG, "Crashing app skipping ANR: " + app + " " + annotation); 761 return; 762 } 763 764 // In case we come through here for the same app before completing 765 // this one, mark as anring now so we will bail out. 766 app.notResponding = true; 767 768 // Log the ANR to the event log. 769 EventLog.writeEvent(EventLogTags.AM_ANR, app.userId, app.pid, 770 app.processName, app.info.flags, annotation); 771 772 // Dump thread traces as quickly as we can, starting with "interesting" processes. 773 firstPids.add(app.pid); 774 775 // Don't dump other PIDs if it's a background ANR 776 isSilentANR = !showBackground && !app.isInterestingToUserLocked() && app.pid != MY_PID; 777 if (!isSilentANR) { 778 int parentPid = app.pid; 779 if (parent != null && parent.app != null && parent.app.pid > 0) { 780 parentPid = parent.app.pid; 781 } 782 if (parentPid != app.pid) firstPids.add(parentPid); 783 784 if (MY_PID != app.pid && MY_PID != parentPid) firstPids.add(MY_PID); 785 786 for (int i = mService.mLruProcesses.size() - 1; i >= 0; i--) { 787 ProcessRecord r = mService.mLruProcesses.get(i); 788 if (r != null && r.thread != null) { 789 int pid = r.pid; 790 if (pid > 0 && pid != app.pid && pid != parentPid && pid != MY_PID) { 791 if (r.persistent) { 792 firstPids.add(pid); 793 if (DEBUG_ANR) Slog.i(TAG, "Adding persistent proc: " + r); 794 } else { 795 lastPids.put(pid, Boolean.TRUE); 796 if (DEBUG_ANR) Slog.i(TAG, "Adding ANR proc: " + r); 797 } 798 } 799 } 800 } 801 } 802 } 803 804 // Log the ANR to the main log. 805 StringBuilder info = new StringBuilder(); 806 info.setLength(0); 807 info.append("ANR in ").append(app.processName); 808 if (activity != null && activity.shortComponentName != null) { 809 info.append(" (").append(activity.shortComponentName).append(")"); 810 } 811 info.append("\n"); 812 info.append("PID: ").append(app.pid).append("\n"); 813 if (annotation != null) { 814 info.append("Reason: ").append(annotation).append("\n"); 815 } 816 if (parent != null && parent != activity) { 817 info.append("Parent: ").append(parent.shortComponentName).append("\n"); 818 } 819 820 ProcessCpuTracker processCpuTracker = new ProcessCpuTracker(true); 821 822 String[] nativeProcs = NATIVE_STACKS_OF_INTEREST; 823 // don't dump native PIDs for background ANRs 824 File tracesFile = null; 825 if (isSilentANR) { 826 tracesFile = mService.dumpStackTraces(true, firstPids, null, lastPids, 827 null); 828 } else { 829 tracesFile = mService.dumpStackTraces(true, firstPids, processCpuTracker, lastPids, 830 nativeProcs); 831 } 832 833 String cpuInfo = null; 834 if (ActivityManagerService.MONITOR_CPU_USAGE) { 835 mService.updateCpuStatsNow(); 836 synchronized (mService.mProcessCpuTracker) { 837 cpuInfo = mService.mProcessCpuTracker.printCurrentState(anrTime); 838 } 839 info.append(processCpuTracker.printCurrentLoad()); 840 info.append(cpuInfo); 841 } 842 843 info.append(processCpuTracker.printCurrentState(anrTime)); 844 845 Slog.e(TAG, info.toString()); 846 if (tracesFile == null) { 847 // There is no trace file, so dump (only) the alleged culprit's threads to the log 848 Process.sendSignal(app.pid, Process.SIGNAL_QUIT); 849 } 850 851 mService.addErrorToDropBox("anr", app, app.processName, activity, parent, annotation, 852 cpuInfo, tracesFile, null); 853 854 if (mService.mController != null) { 855 try { 856 // 0 == show dialog, 1 = keep waiting, -1 = kill process immediately 857 int res = mService.mController.appNotResponding( 858 app.processName, app.pid, info.toString()); 859 if (res != 0) { 860 if (res < 0 && app.pid != MY_PID) { 861 app.kill("anr", true); 862 } else { 863 synchronized (mService) { 864 mService.mServices.scheduleServiceTimeoutLocked(app); 865 } 866 } 867 return; 868 } 869 } catch (RemoteException e) { 870 mService.mController = null; 871 Watchdog.getInstance().setActivityController(null); 872 } 873 } 874 875 synchronized (mService) { 876 mService.mBatteryStatsService.noteProcessAnr(app.processName, app.uid); 877 878 if (isSilentANR) { 879 app.kill("bg anr", true); 880 return; 881 } 882 883 // Set the app's notResponding state, and look up the errorReportReceiver 884 makeAppNotRespondingLocked(app, 885 activity != null ? activity.shortComponentName : null, 886 annotation != null ? "ANR " + annotation : "ANR", 887 info.toString()); 888 889 // Bring up the infamous App Not Responding dialog 890 Message msg = Message.obtain(); 891 HashMap<String, Object> map = new HashMap<String, Object>(); 892 msg.what = ActivityManagerService.SHOW_NOT_RESPONDING_UI_MSG; 893 msg.obj = map; 894 msg.arg1 = aboveSystem ? 1 : 0; 895 map.put("app", app); 896 if (activity != null) { 897 map.put("activity", activity); 898 } 899 900 mService.mUiHandler.sendMessage(msg); 901 } 902 } 903 904 private void makeAppNotRespondingLocked(ProcessRecord app, 905 String activity, String shortMsg, String longMsg) { 906 app.notResponding = true; 907 app.notRespondingReport = generateProcessError(app, 908 ActivityManager.ProcessErrorStateInfo.NOT_RESPONDING, 909 activity, shortMsg, longMsg, null); 910 startAppProblemLocked(app); 911 app.stopFreezingAllLocked(); 912 } 913 914 void handleShowAnrUi(Message msg) { 915 Dialog d = null; 916 synchronized (mService) { 917 HashMap<String, Object> data = (HashMap<String, Object>) msg.obj; 918 ProcessRecord proc = (ProcessRecord)data.get("app"); 919 if (proc != null && proc.anrDialog != null) { 920 Slog.e(TAG, "App already has anr dialog: " + proc); 921 MetricsLogger.action(mContext, MetricsProto.MetricsEvent.ACTION_APP_ANR, 922 AppNotRespondingDialog.ALREADY_SHOWING); 923 return; 924 } 925 926 Intent intent = new Intent("android.intent.action.ANR"); 927 if (!mService.mProcessesReady) { 928 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 929 | Intent.FLAG_RECEIVER_FOREGROUND); 930 } 931 mService.broadcastIntentLocked(null, null, intent, 932 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 933 null, false, false, MY_PID, Process.SYSTEM_UID, 0 /* TODO: Verify */); 934 935 if (mService.canShowErrorDialogs()) { 936 d = new AppNotRespondingDialog(mService, 937 mContext, proc, (ActivityRecord)data.get("activity"), 938 msg.arg1 != 0); 939 proc.anrDialog = d; 940 } else { 941 MetricsLogger.action(mContext, MetricsProto.MetricsEvent.ACTION_APP_ANR, 942 AppNotRespondingDialog.CANT_SHOW); 943 // Just kill the app if there is no dialog to be shown. 944 mService.killAppAtUsersRequest(proc, null); 945 } 946 } 947 // If we've created a crash dialog, show it without the lock held 948 if (d != null) { 949 d.show(); 950 } 951 } 952 953 /** 954 * Information about a process that is currently marked as bad. 955 */ 956 static final class BadProcessInfo { 957 BadProcessInfo(long time, String shortMsg, String longMsg, String stack) { 958 this.time = time; 959 this.shortMsg = shortMsg; 960 this.longMsg = longMsg; 961 this.stack = stack; 962 } 963 964 final long time; 965 final String shortMsg; 966 final String longMsg; 967 final String stack; 968 } 969 970 } 971
