Framework篇 - framework 层的 crash 处理流程_android 系统framework收集所有进程 crash

本文源代码基于 Android 7.0。

App crash (全称 Application crash)，对于 crash 可分为 native crash 和 framework crash (包含 app crash 在内)，对于 crash 相信很多 app 开发者都会遇到，那么上层什么时候会出现 crash 呢，系统又是如何处理 crash 的呢？

例如，在 app 中大家经常使用 try...catch 语句，那么如果没有有效 catch exception，就会导致应用 crash。发现没有 catch exception，系统便会来进行捕获，并进入 crash 流程。如果你是从事 Android 系统开发或者架构相关工作，或者遇到需要解系统性的疑难杂症，那么很有必要了解系统 crash 处理流程。

 

目录：

1. 概述
2. framework crash 处理流程
3. 拓展

 

1. 概述

上层应用都是由 Zygote fork 孵化而来，分为 system_server 系统进程和各种应用进程，在这些进程创建之初会设置未捕获异常的处理器，当系统抛出未捕获的异常时，最终都交给异常处理器。

对于 system_server 进程：前面的文章 SystemServer 进程详解 分析了 system_server 的启动过程。system_server 启动过程中由RuntimeInit.java 的 commonInit 方法设置 UncaughtHandler，用于处理未捕获异常。

对于普通应用进程：进程创建过程中，同样会调用 RuntimeInit.java 的 commonInit 方法设置 UncaughtHandler。

/base/core/java/com/android/internal/os/RuntimeInit.java

    private static final void commonInit() {
        if (DEBUG) Slog.d(TAG, "Entered RuntimeInit!");
 
        /* set default handler; this applies to all threads in the VM */
        Thread.setDefaultUncaughtExceptionHandler(new UncaughtHandler());
    }

注意，Thread.setDefaultUncaughtExceptionHandler() 可以捕获所有线程的异常，而 Thread.currentThread().setDefaultUncaughtExceptionHandler() 是作用在当前线程上的。

 

 

2. framework crash 处理流程

 

• 2.1 UncaughtHandler

setDefaultUncaughtExceptionHandler() 只是将异常处理器 handler 对象赋给 Thread 成员变量，即Thread.defaultUncaughtHandler = new UncaughtHandler()，接下来看看 UncaughtHandler 对象实例化过程。

/base/core/java/com/android/internal/os/RuntimeInit.java

private static class UncaughtHandler implements Thread.UncaughtExceptionHandler {
        public void uncaughtException(Thread t, Throwable e) {
            try {
                // 保证crash处理过程不会重入
                if (mCrashing) return;
                mCrashing = true;
 
                if (mApplicationObject == null) {
                    // system_server进程
                    Clog_e(TAG, "*** FATAL EXCEPTION IN SYSTEM PROCESS: " + t.getName(), e)
                } else {
                    // 普通应用进程
                    StringBuilder message = new StringBuilder();
                    message.append("FATAL EXCEPTION: ").append(t.getName()).append("\n");
                    final String processName = ActivityThread.currentProcessName();
                    if (processName != null) {
                        message.append("Process: ").append(processName).append(", ");
                    }
                    message.append("PID: ").append(Process.myPid());
                    Clog_e(TAG, message.toString(), e);
                }
 
                if (ActivityThread.currentActivityThread() != null) {
                    ActivityThread.currentActivityThread().stopProfiling();
                }
 
                // 启动crash对话框，等待处理完成
                ActivityManagerNative.getDefault().handleApplicationCrash(
                        mApplicationObject, new ApplicationErrorReport.CrashInfo(e));
            } catch (Throwable t2) {
                // ...
            } finally {
                // 确保当前进程彻底杀掉
                Process.killProcess(Process.myPid());
                System.exit(10);
            }
        }
    }

system 进程 crash 时的 log 信息： 

开头*** FATAL EXCEPTION IN SYSTEM PROCESS [线程名]；
接着输出发生crash时的调用栈信息。

app 进程 crash 时的 log 信息：

开头 FATAL EXCEPTION: [线程名]；
紧接着 Process: [进程名]，PID: [进程id]；
最后输出发生 crash 时的调用栈信息。

看到这里，你就会发现要从 log 中搜索 crash 信息，只需要搜索关键词 FATAL EXCEPTION；如果需要进一步筛选只搜索系统crash 信息，则可以搜索的关键词可以有多样，比如 *** FATAL EXCEPTION。

当输出完 crash 信息到 logcat 里面，这只是 crash 流程的刚开始阶段，接下来弹出 crash 对话框，ActivityManagerNative.getDefault() 返回的是 ActivityManagerProxy，ActivityManagerProxy 经过 Binder 调用最终交给ActivityManagerService 中相应的方法去处理，故接下来调用的是 ActivityManagerService.handleApplicationCrash()。

注意: mApplicationObject 等于 null，一定不是普通的 app 进程。但是除了 system 进程，也有可能是 shell 进程，即通过app_process + 命令参数 的方式创建的进程。

 

• 2.2 ActivityManagerService.handleApplicationCrash()

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

    public void handleApplicationCrash(IBinder app, ApplicationErrorReport.CrashInfo crashInfo) {
        // 获取进程record对象
        ProcessRecord r = findAppProcess(app, "Crash");
        final String processName = app == null ? "system_server"
                : (r == null ? "unknown" : r.processName);
 
        handleApplicationCrashInner("crash", r, processName, crashInfo);
    }

有了进程记录对象 ProcessRecord 和进程名 processName，则进入执行 Crash 处理方法。

 

• 2.3 ActivityManagerService.handleApplicationCrashInner()

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

void handleApplicationCrashInner(String eventType, ProcessRecord r, String processName,
            ApplicationErrorReport.CrashInfo crashInfo) {
        // 将Crash信息写入到Event log
        EventLog.writeEvent(EventLogTags.AM_CRASH, Binder.getCallingPid(),
                UserHandle.getUserId(Binder.getCallingUid()), processName,
                r == null ? -1 : r.info.flags,
                crashInfo.exceptionClassName,
                crashInfo.exceptionMessage,
                crashInfo.throwFileName,
                crashInfo.throwLineNumber);
        // 将错误信息添加到DropBox
        addErrorToDropBox(eventType, r, processName, null, null, null, null, null, crashInfo);
 
        mAppErrors.crashApplication(r, crashInfo);
    }

addErrorToDropBox 是将 crash 信息输出到目录 /data/system/dropbox，例如 system_server 的 dropbox 文件名为system_server_crash@xxx.txt (xxx代表的是时间戳)。

 

• 2.4 AppErrors.crashApplication()

/base/services/core/java/com/android/server/am/AppErrors.java

void crashApplication(ProcessRecord r, ApplicationErrorReport.CrashInfo crashInfo) {
        final long origId = Binder.clearCallingIdentity();
        try {
            crashApplicationInner(r, crashInfo);
        } finally {
            Binder.restoreCallingIdentity(origId);
        }
    }
 
void crashApplicationInner(ProcessRecord r, ApplicationErrorReport.CrashInfo crashInfo) {
        // 时间戳
        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;
        }
 
        AppErrorResult result = new AppErrorResult();
        TaskRecord task;
        synchronized (mService) {
            // 当存在 ActivityController 的情况，比如 monkey，则调用 monkey 的 appCrashed处理逻辑并返回
            if (handleAppCrashInActivityController(r, crashInfo, shortMsg, longMsg, stackTrace,
                    timeMillis)) {
                return;
            }
 
            if (r != null && r.instrumentationClass != null) {
                return;
            }
 
            if (r != null) {
                mService.mBatteryStatsService.noteProcessCrash(r.processName, r.uid);
            }
            
            // 错误弹窗
            AppErrorDialog.Data data = new AppErrorDialog.Data();
            data.result = result;
            data.proc = r;
            if (r == null || !makeAppCrashingLocked(r, shortMsg, longMsg, stackTrace, data)) {
                return;
            }
 
            Message msg = Message.obtain();
            msg.what = ActivityManagerService.SHOW_ERROR_UI_MSG;
 
            task = data.task;
            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) {
                // 重启
            }
            if (res == AppErrorDialog.FORCE_QUIT) {
                long orig = Binder.clearCallingIdentity();
                try {
                    // 杀死进程
                } finally {
                    Binder.restoreCallingIdentity(orig);
                }
            }
            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);
            }
        }
    }

当存在 ActivityController 的情况，比如 monkey，则调用 monkey 的 appCrashed处理逻辑并返回。否则弹出 crash 框让用户选择是重启还是退出。

 

 

3. 拓展

        Thread.setDefaultUncaughtExceptionHandler(...);

调用这句代码可以捕获所有线程的异常，看看 Thread 类中的实现：

public class Thread implements Runnable {
 
    private static UncaughtExceptionHandler defaultUncaughtHandler;
 
    public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() {
        return defaultUncaughtHandler;
    }
 
    public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler handler)                     {
        Thread.defaultUncaughtHandler = handler;
    }
}

可以看到，就是一个全局变量。所以如果我们 app 如果自己设置了 UncaughtExceptionHandler，是会覆盖掉系统的默认设置的。也就不会执行 framework crash 处理流程，而是执行你自定义的逻辑。如果自己设置 UncaughtExceptionHandler，那么可以用来实现错误日志上报，同时也能不让应用崩溃，不弹出 crash 窗。