《软件调试》读书笔记：第13章 硬错误和蓝屏

会话管理器进程SMSS.exe是系统启动后的第一个用户态进程，负责启动和监护windows子系统进程：CSRSS.exe和登陆管理进程：WinLogon

SMSS.exe从注册表中查询子系统exe文件的位置，并且启动它

CSRSS是windows子系统进程，自NT4以后窗口管理和GDI的主体实现被移出了CSRSS放到了win32k.sys中。

CSRSS监管着所有windows线程和进程，每个进程在创建后都要到这里登记才能运行，退出时也要报告注销。(维护了Windows子系统层面上的记录结构)

CSRSS具有桌面管理、终端登录、控制台管理、HardError报告等方面的重要作用。

为了适应恶劣环境下的错误提示的需要，Windows定义了硬错误提示机制。

硬错误本意是硬件有关错误，后来泛指严重的错误。

硬错误可以在用户态使用也可以在内核态使用。

硬错误的核心处理函数是内核中的ExpRaiseHardError函数。

在我们看这个函数的源码前，先想一想，发送硬错误消息，首先要的是找到发送硬错误的端口。

这个端口怎么找？是通过一系列的设置和标志位来判断的。　　

如下是具体的程序内容

NTSTATUS
ExpRaiseHardError (
    IN NTSTATUS ErrorStatus,
    IN ULONG NumberOfParameters,
    IN ULONG UnicodeStringParameterMask,
    IN PULONG_PTR Parameters,
    IN ULONG ValidResponseOptions,
    OUT PULONG Response
    )
{
    PTEB Teb;
    PETHREAD Thread;
    PEPROCESS Process;
    ULONG_PTR MessageBuffer[PORT_TOTAL_MAXIMUM_MESSAGE_LENGTH/sizeof(ULONG_PTR)];
    PHARDERROR_MSG m;
    NTSTATUS Status;
    HANDLE ErrorPort;
    KPROCESSOR_MODE PreviousMode;
    BOOLEAN DoingShutdown;

    PAGED_CODE();
    //要发送的消息结构
    m = (PHARDERROR_MSG)&MessageBuffer[0];
    PreviousMode = KeGetPreviousMode();

    DoingShutdown = FALSE;
    //如果参数要求关机，就检查是否有关机权限
    if (ValidResponseOptions == OptionShutdownSystem) {

        //
        // Check to see if the caller has the privilege to make this call.
        //

        if (!SeSinglePrivilegeCheck (SeShutdownPrivilege, PreviousMode)) {
            return STATUS_PRIVILEGE_NOT_HELD;
        }

        ExReadyForErrors = FALSE;
        HardErrorState = SHUTDOWN;
        DoingShutdown = TRUE;
    }

    Thread = PsGetCurrentThread();
    Process = PsGetCurrentProcess();

    //
    // If the default handler is not installed, then
    // call the fatal hard error handler if the error
    // status is error
    //
    // Let GDI override this since it does not want to crash the machine
    // when a bad driver was loaded via MmLoadSystemImage.
    //

    if ((Thread->CrossThreadFlags & PS_CROSS_THREAD_FLAGS_HARD_ERRORS_DISABLED) == 0) {
        //如果满足这个标志位说明用户态HardError系统还没有准备好，只能在内核态去提示这个HardError了
        if (NT_ERROR(ErrorStatus) && (HardErrorState == STARTING || DoingShutdown)) {
        //而所谓的在内核态提示HardError就是执行这个函数了，实质上就是一个KeBugCheckEx,也就是说想着内核态提示HardError只能是通过抛出蓝屏
            ExpSystemErrorHandler (
                ErrorStatus,
                NumberOfParameters,
                UnicodeStringParameterMask,
                Parameters,
                (BOOLEAN)((PreviousMode != KernelMode) ? TRUE : FALSE));
        }
    }

    //
    // If the process has an error port, then if it wants default
    // handling, use its port. If it disabled default handling, then
    // return the error to the caller. If the process does not
    // have a port, then use the registered default handler.
    //

    ErrorPort = NULL;
    //这个就是通过各种标志位来判断硬错误端口是什么了。对于一个进程来说只有异常端口和调试端口两个东西，并没有单独指定硬错误端口的结构。
    if (Process->ExceptionPort) {
        //异常端口存在时
        if (Process->DefaultHardErrorProcessing & 1) {
            //这个标志位存在时，异常端口就是硬错误端口
            ErrorPort = Process->ExceptionPort;
        } else {

            //
            // If error processing is disabled, check the error override
            // status.
            //

            if (ErrorStatus & HARDERROR_OVERRIDE_ERRORMODE) {
                //满足这个条件的话，也是异常端口
                ErrorPort = Process->ExceptionPort;
            }
        }
    } else {
        if (Process->DefaultHardErrorProcessing & 1) {
            ErrorPort = ExpDefaultErrorPort;
        } else {

            //
            // If error processing is disabled, check the error override
            // status.
            //

            if (ErrorStatus & HARDERROR_OVERRIDE_ERRORMODE) {
                ErrorPort = ExpDefaultErrorPort;
            }
        }
    }
    //虽然上面比较的那么热闹。。但是ExpDefaultErrorPort和ExeceptionPort的值其实是一样的
    //都是CSRSS进程的WindowsApiPort端口。这是一个LPC端口对象

    if ((Thread->CrossThreadFlags&PS_CROSS_THREAD_FLAGS_HARD_ERRORS_DISABLED) != 0) {
        ErrorPort = NULL;
    }
    //设置了禁止硬错误就把ErrorPort清零
    if ((ErrorPort != NULL) && (!IS_SYSTEM_THREAD(Thread))) {
        Teb = (PTEB)PsGetCurrentThread()->Tcb.Teb;
        try {
            if (Teb->HardErrorMode & RTL_ERRORMODE_FAILCRITICALERRORS) {
                ErrorPort = NULL;
            }
        } except (EXCEPTION_EXECUTE_HANDLER) {
            ;
        }
    }

    if (ErrorPort == NULL) {
        *Response = (ULONG)ResponseReturnToCaller;
        return STATUS_SUCCESS;
    }
    //自己给自己发异常？出现问题了
    if (Process == ExpDefaultErrorPortProcess) {
        if (NT_ERROR(ErrorStatus)) {
            ExpSystemErrorHandler (ErrorStatus,
                                   NumberOfParameters,
                                   UnicodeStringParameterMask,
                                   Parameters,
                                   (BOOLEAN)((PreviousMode != KernelMode) ? TRUE : FALSE));
        }
        *Response = (ULONG)ResponseReturnToCaller;
        Status = STATUS_SUCCESS;
        return Status;
    }

    m->h.u1.Length = HARDERROR_API_MSG_LENGTH;
    m->h.u2.ZeroInit = LPC_ERROR_EVENT;
    m->Status = ErrorStatus & ~HARDERROR_OVERRIDE_ERRORMODE;
    m->ValidResponseOptions = ValidResponseOptions;
    m->UnicodeStringParameterMask = UnicodeStringParameterMask;
    m->NumberOfParameters = NumberOfParameters;

    if (Parameters != NULL) {
        try {
            RtlCopyMemory (&m->Parameters,
                           Parameters,
                           sizeof(ULONG_PTR)*NumberOfParameters);
        } except (EXCEPTION_EXECUTE_HANDLER) {
        }
    }

    KeQuerySystemTime(&m->ErrorTime);
    //执行发送函数
    Status = LpcRequestWaitReplyPortEx (ErrorPort,
                                        (PPORT_MESSAGE) m,
                                        (PPORT_MESSAGE) m);

    if (NT_SUCCESS(Status)) {
        switch (m->Response) {
            //作为一个返回值
            case ResponseReturnToCaller :
            case ResponseNotHandled :
            case ResponseAbort :
            case ResponseCancel :
            case ResponseIgnore :
            case ResponseNo :
            case ResponseOk :
            case ResponseRetry :
            case ResponseYes :
            case ResponseTryAgain :
            case ResponseContinue :
                break;
            default:
                m->Response = (ULONG)ResponseReturnToCaller;
                break;
        }
        *Response = m->Response;
    }

    return Status;
}

这个函数把硬错误信息发送到了CSRSS进程的WindowsApiPort端口上去。

接下来就是看CSRSS进程是怎么接受并处理这个硬错误消息的。

CSRSS进程中专门启用了一个线程来监听并处理WindowsApiPort端口的内容

CsrApiRequestThread就是这个专门用来监听的工作线程

PORT_MESSAGE是发送的LPC端口的数据结构。

CSRSS负责后续的处理工作，并进行用户层面的弹出提示。