861 lines
25 KiB
C
861 lines
25 KiB
C
/*++
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
harderr.c
|
|
|
|
Abstract:
|
|
|
|
This module implements NT Hard Error APIs
|
|
|
|
Author:
|
|
|
|
Mark Lucovsky (markl) 04-Jul-1991
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "exp.h"
|
|
|
|
extern ULONG KiBugCheckData[5];
|
|
extern ULONG KeBugCheckCount;
|
|
|
|
NTSTATUS
|
|
ExpRaiseHardError(
|
|
IN NTSTATUS ErrorStatus,
|
|
IN ULONG NumberOfParameters,
|
|
IN ULONG UnicodeStringParameterMask,
|
|
IN PULONG_PTR Parameters,
|
|
IN ULONG ValidResponseOptions,
|
|
OUT PULONG Response
|
|
);
|
|
|
|
VOID
|
|
ExpSystemErrorHandler(
|
|
IN NTSTATUS ErrorStatus,
|
|
IN ULONG NumberOfParameters,
|
|
IN ULONG UnicodeStringParameterMask,
|
|
IN PULONG_PTR Parameters,
|
|
IN BOOLEAN CallShutdown
|
|
);
|
|
|
|
#if defined(ALLOC_PRAGMA)
|
|
#pragma alloc_text(PAGE, NtRaiseHardError)
|
|
#pragma alloc_text(PAGE, NtSetDefaultHardErrorPort)
|
|
#pragma alloc_text(PAGE, ExRaiseHardError)
|
|
#pragma alloc_text(PAGE, ExpRaiseHardError)
|
|
#pragma alloc_text(PAGELK, ExpSystemErrorHandler)
|
|
#endif
|
|
|
|
#define HARDERROR_MSG_OVERHEAD (sizeof(HARDERROR_MSG) - sizeof(PORT_MESSAGE))
|
|
#define HARDERROR_API_MSG_LENGTH \
|
|
sizeof(HARDERROR_MSG)<<16 | (HARDERROR_MSG_OVERHEAD)
|
|
|
|
PEPROCESS ExpDefaultErrorPortProcess;
|
|
BOOLEAN ExReadyForErrors = FALSE;
|
|
BOOLEAN ExpTooLateForErrors = FALSE;
|
|
HANDLE ExpDefaultErrorPort;
|
|
extern PVOID PsSystemDllDllBase;
|
|
|
|
VOID
|
|
ExpSystemErrorHandler(
|
|
IN NTSTATUS ErrorStatus,
|
|
IN ULONG NumberOfParameters,
|
|
IN ULONG UnicodeStringParameterMask,
|
|
IN PULONG_PTR Parameters,
|
|
IN BOOLEAN CallShutdown
|
|
)
|
|
{
|
|
|
|
ULONG Counter;
|
|
ANSI_STRING AnsiString;
|
|
NTSTATUS Status;
|
|
ULONG_PTR ParameterVector[MAXIMUM_HARDERROR_PARAMETERS];
|
|
CHAR DefaultFormatBuffer[32];
|
|
CHAR ExpSystemErrorBuffer[256];
|
|
PMESSAGE_RESOURCE_ENTRY MessageEntry;
|
|
PSZ ErrorCaption;
|
|
PSZ ErrorFormatString;
|
|
ANSI_STRING Astr;
|
|
UNICODE_STRING Ustr;
|
|
OEM_STRING Ostr;
|
|
PSZ OemCaption;
|
|
PSZ OemMessage;
|
|
PSZ UnknownHardError = "Unknown Hard Error";
|
|
PVOID UnlockHandle;
|
|
CONTEXT ContextSave;
|
|
|
|
|
|
// This handler is called whenever a hard error occurs before the
|
|
// default handler has been installed.
|
|
|
|
// This is done regardless of whether or not the process has chosen
|
|
// default hard error processing.
|
|
|
|
|
|
|
|
|
|
// Capture the callers context as closely as possible into the debugger's
|
|
// processor state area of the Prcb
|
|
|
|
// N.B. There may be some prologue code that shuffles registers such that
|
|
// they get destroyed.
|
|
|
|
// this code is here only for crash dumps
|
|
RtlCaptureContext(&KeGetCurrentPrcb()->ProcessorState.ContextFrame);
|
|
KiSaveProcessorControlState(&KeGetCurrentPrcb()->ProcessorState);
|
|
ContextSave = KeGetCurrentPrcb()->ProcessorState.ContextFrame;
|
|
|
|
|
|
DefaultFormatBuffer[0] = '\0';
|
|
RtlZeroMemory(ParameterVector,sizeof(ParameterVector));
|
|
for(Counter=0;Counter < NumberOfParameters;Counter++){
|
|
ParameterVector[Counter] = Parameters[Counter];
|
|
}
|
|
|
|
for(Counter=0;Counter < NumberOfParameters;Counter++){
|
|
if ( UnicodeStringParameterMask & 1<<Counter ) {
|
|
strcat(DefaultFormatBuffer," %s");
|
|
RtlUnicodeStringToAnsiString(&AnsiString,(PUNICODE_STRING)Parameters[Counter],TRUE);
|
|
ParameterVector[Counter] = (ULONG_PTR)AnsiString.Buffer;
|
|
}
|
|
else {
|
|
strcat(DefaultFormatBuffer," %x");
|
|
}
|
|
}
|
|
strcat(DefaultFormatBuffer,"\n");
|
|
|
|
|
|
// HELP where do I get the resource from !
|
|
|
|
|
|
if ( PsSystemDllDllBase ) {
|
|
|
|
try {
|
|
|
|
|
|
// If we are on a DBCS code page, we have to use ENGLISH resource
|
|
// instead of default resource because HalDisplayString() can only
|
|
// display ASCII characters on the blue screen.
|
|
|
|
|
|
Status = RtlFindMessage(PsSystemDllDllBase,
|
|
11,
|
|
NlsMbCodePageTag ?
|
|
MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US) :
|
|
0,
|
|
ErrorStatus,
|
|
&MessageEntry);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
ErrorCaption = ErrorFormatString = UnknownHardError;
|
|
}
|
|
else {
|
|
if (MessageEntry->Flags & MESSAGE_RESOURCE_UNICODE) {
|
|
|
|
|
|
// Message resource is Unicode. Convert to ANSI
|
|
|
|
|
|
RtlInitUnicodeString(&Ustr, (PCWSTR)MessageEntry->Text);
|
|
Astr.Length = (USHORT) RtlUnicodeStringToAnsiSize(&Ustr);
|
|
ErrorCaption = ExAllocatePoolWithTag(NonPagedPool,Astr.Length+16, ' rrE');
|
|
|
|
if (ErrorCaption) {
|
|
Astr.MaximumLength = Astr.Length + 16;
|
|
Astr.Buffer = ErrorCaption;
|
|
Status = RtlUnicodeStringToAnsiString(&Astr, &Ustr, FALSE);
|
|
if ( !NT_SUCCESS(Status) ) {
|
|
ExFreePool(ErrorCaption);
|
|
ErrorCaption = ErrorFormatString = UnknownHardError;
|
|
}
|
|
}
|
|
else {
|
|
ErrorCaption = ErrorFormatString = UnknownHardError;
|
|
}
|
|
|
|
}
|
|
else {
|
|
ErrorCaption = ExAllocatePoolWithTag(NonPagedPool,strlen(MessageEntry->Text)+16, ' rrE');
|
|
if ( ErrorCaption ) {
|
|
strcpy(ErrorCaption,MessageEntry->Text);
|
|
}
|
|
else {
|
|
ErrorCaption = ErrorFormatString = UnknownHardError;
|
|
}
|
|
}
|
|
|
|
if (ErrorCaption != UnknownHardError) {
|
|
|
|
// It's assumed the Error String from the message table is in the format:
|
|
// {ErrorCaption}\r\n\0ErrorFormatString\0. Parse out the caption.
|
|
|
|
ErrorFormatString = ErrorCaption;
|
|
Counter = strlen(ErrorCaption);
|
|
while ( Counter && *ErrorFormatString >= ' ' ) {
|
|
ErrorFormatString++;
|
|
Counter--;
|
|
}
|
|
|
|
*ErrorFormatString++ = '\0';
|
|
Counter--;
|
|
|
|
while ( Counter && *ErrorFormatString && *ErrorFormatString <= ' ') {
|
|
ErrorFormatString++;
|
|
Counter--;
|
|
}
|
|
}
|
|
|
|
if (!Counter) {
|
|
// Oops - Bad Format String.
|
|
ErrorFormatString = "";
|
|
}
|
|
}
|
|
}
|
|
except ( EXCEPTION_EXECUTE_HANDLER ) {
|
|
ErrorFormatString = UnknownHardError;
|
|
ErrorCaption = UnknownHardError;
|
|
}
|
|
}
|
|
else {
|
|
ErrorFormatString = DefaultFormatBuffer;
|
|
ErrorCaption = UnknownHardError;
|
|
}
|
|
|
|
try {
|
|
_snprintf( ExpSystemErrorBuffer, sizeof( ExpSystemErrorBuffer ),
|
|
"\nSTOP: %lx %s\n", ErrorStatus,ErrorCaption);
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER) {
|
|
_snprintf( ExpSystemErrorBuffer, sizeof( ExpSystemErrorBuffer ),
|
|
"\nHardError %lx\n", ErrorStatus);
|
|
}
|
|
|
|
UnlockHandle = MmLockPagableCodeSection((PVOID)ExpSystemErrorHandler);
|
|
ASSERT(UnlockHandle);
|
|
|
|
|
|
// take the caption and convert it to OEM
|
|
|
|
|
|
OemCaption = UnknownHardError;
|
|
OemMessage = UnknownHardError;
|
|
|
|
RtlInitAnsiString(&Astr,ExpSystemErrorBuffer);
|
|
Status = RtlAnsiStringToUnicodeString(&Ustr,&Astr,TRUE);
|
|
if ( !NT_SUCCESS(Status) ) {
|
|
goto punt1;
|
|
}
|
|
|
|
|
|
// Allocate the OEM string out of nonpaged pool so that bugcheck
|
|
// can read it.
|
|
|
|
Ostr.Length = (USHORT)RtlUnicodeStringToOemSize(&Ustr);
|
|
Ostr.MaximumLength = Ostr.Length;
|
|
Ostr.Buffer = ExAllocatePoolWithTag(NonPagedPool, Ostr.Length, ' rrE');
|
|
OemCaption = Ostr.Buffer;
|
|
if (Ostr.Buffer) {
|
|
Status = RtlUnicodeStringToOemString(&Ostr,&Ustr,FALSE);
|
|
if ( !NT_SUCCESS(Status) ) {
|
|
goto punt1;
|
|
}
|
|
}
|
|
|
|
|
|
// Can't do much of anything after calling HalDisplayString...
|
|
|
|
|
|
punt1:;
|
|
try {
|
|
_snprintf( ExpSystemErrorBuffer, sizeof( ExpSystemErrorBuffer ),
|
|
ErrorFormatString,
|
|
ParameterVector[0],
|
|
ParameterVector[1],
|
|
ParameterVector[2],
|
|
ParameterVector[3]
|
|
);
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER) {
|
|
_snprintf( ExpSystemErrorBuffer, sizeof( ExpSystemErrorBuffer ),
|
|
"Exception Processing Message %lx Parameters %lx %lx %lx %lx",
|
|
ErrorStatus,
|
|
ParameterVector[0],
|
|
ParameterVector[1],
|
|
ParameterVector[2],
|
|
ParameterVector[3]
|
|
);
|
|
}
|
|
|
|
|
|
RtlInitAnsiString(&Astr,ExpSystemErrorBuffer);
|
|
Status = RtlAnsiStringToUnicodeString(&Ustr,&Astr,TRUE);
|
|
if ( !NT_SUCCESS(Status) ) {
|
|
goto punt2;
|
|
}
|
|
|
|
// Allocate the OEM string out of nonpaged pool so that bugcheck
|
|
// can read it.
|
|
|
|
Ostr.Length = (USHORT)RtlUnicodeStringToOemSize(&Ustr);
|
|
Ostr.MaximumLength = Ostr.Length;
|
|
Ostr.Buffer = ExAllocatePoolWithTag(NonPagedPool, Ostr.Length, ' rrE');
|
|
OemMessage = Ostr.Buffer;
|
|
if (Ostr.Buffer) {
|
|
Status = RtlUnicodeStringToOemString(&Ostr,&Ustr,FALSE);
|
|
if ( !NT_SUCCESS(Status) ) {
|
|
goto punt2;
|
|
}
|
|
}
|
|
|
|
punt2:;
|
|
ASSERT(sizeof(PVOID) == sizeof(ULONG_PTR));
|
|
ASSERT(sizeof(ULONG) == sizeof(NTSTATUS));
|
|
|
|
|
|
// We don't come back from here.
|
|
|
|
|
|
if (CallShutdown) {
|
|
|
|
PoShutdownBugCheck(
|
|
FALSE,
|
|
FATAL_UNHANDLED_HARD_ERROR,
|
|
(ULONG)ErrorStatus,
|
|
(ULONG_PTR)&(ParameterVector[0]),
|
|
(ULONG_PTR)OemCaption,
|
|
(ULONG_PTR)OemMessage
|
|
);
|
|
|
|
}
|
|
else {
|
|
|
|
KeBugCheckEx(
|
|
FATAL_UNHANDLED_HARD_ERROR,
|
|
(ULONG)ErrorStatus,
|
|
(ULONG_PTR)&(ParameterVector[0]),
|
|
(ULONG_PTR)OemCaption,
|
|
(ULONG_PTR)OemMessage
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ExpRaiseHardError(
|
|
IN NTSTATUS ErrorStatus,
|
|
IN ULONG NumberOfParameters,
|
|
IN ULONG UnicodeStringParameterMask,
|
|
IN PULONG_PTR Parameters,
|
|
IN ULONG ValidResponseOptions,
|
|
OUT PULONG Response
|
|
)
|
|
{
|
|
PEPROCESS Process;
|
|
ULONG_PTR MessageBuffer[PORT_MAXIMUM_MESSAGE_LENGTH/sizeof(ULONG_PTR)];
|
|
PHARDERROR_MSG m;
|
|
NTSTATUS Status;
|
|
HANDLE ErrorPort;
|
|
KPROCESSOR_MODE PreviousMode;
|
|
|
|
PAGED_CODE();
|
|
|
|
m = (PHARDERROR_MSG)&MessageBuffer[0];
|
|
PreviousMode = KeGetPreviousMode();
|
|
|
|
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;
|
|
}
|
|
|
|
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 ( !(PsGetCurrentThread()->HardErrorsAreDisabled) ) {
|
|
if (ExReadyForErrors == FALSE && NT_ERROR(ErrorStatus)){
|
|
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.
|
|
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 {
|
|
ErrorPort = NULL;
|
|
}
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
else {
|
|
ErrorPort = NULL;
|
|
}
|
|
ErrorPort = NULL;
|
|
}
|
|
}
|
|
|
|
if ( PsGetCurrentThread()->HardErrorsAreDisabled ) {
|
|
ErrorPort = NULL;
|
|
}
|
|
|
|
if ( !IS_SYSTEM_THREAD(PsGetCurrentThread()) ) {
|
|
try {
|
|
PTEB Teb;
|
|
Teb = (PTEB)PsGetCurrentThread()->Tcb.Teb;
|
|
if ( Teb->HardErrorsAreDisabled ) {
|
|
ErrorPort = NULL;
|
|
}
|
|
}
|
|
except (EXCEPTION_EXECUTE_HANDLER) {
|
|
;
|
|
}
|
|
}
|
|
|
|
if ( ErrorPort ) {
|
|
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 ) {
|
|
RtlMoveMemory(&m->Parameters,Parameters, sizeof(ULONG_PTR)*NumberOfParameters);
|
|
}
|
|
KeQuerySystemTime(&m->ErrorTime);
|
|
|
|
Status = LpcRequestWaitReplyPort(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;
|
|
}
|
|
}
|
|
else {
|
|
*Response = (ULONG)ResponseReturnToCaller;
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
NtRaiseHardError(
|
|
IN NTSTATUS ErrorStatus,
|
|
IN ULONG NumberOfParameters,
|
|
IN ULONG UnicodeStringParameterMask,
|
|
IN PULONG_PTR Parameters,
|
|
IN ULONG ValidResponseOptions,
|
|
OUT PULONG Response
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
PULONG_PTR CapturedParameters;
|
|
KPROCESSOR_MODE PreviousMode;
|
|
ULONG LocalResponse;
|
|
UNICODE_STRING CapturedString;
|
|
ULONG Counter;
|
|
|
|
PAGED_CODE();
|
|
|
|
if ( NumberOfParameters > MAXIMUM_HARDERROR_PARAMETERS ) {
|
|
return STATUS_INVALID_PARAMETER_2;
|
|
}
|
|
|
|
if ( ARGUMENT_PRESENT(Parameters) && NumberOfParameters == 0 ) {
|
|
return STATUS_INVALID_PARAMETER_2;
|
|
}
|
|
|
|
PreviousMode = KeGetPreviousMode();
|
|
if (PreviousMode != KernelMode) {
|
|
switch ( ValidResponseOptions ) {
|
|
case OptionAbortRetryIgnore :
|
|
case OptionOk :
|
|
case OptionOkCancel :
|
|
case OptionRetryCancel :
|
|
case OptionYesNo :
|
|
case OptionYesNoCancel :
|
|
case OptionShutdownSystem :
|
|
case OptionOkNoWait :
|
|
case OptionCancelTryContinue:
|
|
break;
|
|
default :
|
|
return STATUS_INVALID_PARAMETER_4;
|
|
}
|
|
|
|
CapturedParameters = NULL;
|
|
try {
|
|
ProbeForWriteUlong(Response);
|
|
|
|
if ( ARGUMENT_PRESENT(Parameters) ) {
|
|
ProbeForRead(
|
|
Parameters,
|
|
sizeof(ULONG_PTR)*NumberOfParameters,
|
|
sizeof(ULONG_PTR)
|
|
);
|
|
CapturedParameters = ExAllocatePoolWithTag(PagedPool,sizeof(ULONG_PTR)*NumberOfParameters, ' rrE');
|
|
if ( !CapturedParameters ) {
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
RtlMoveMemory(CapturedParameters,Parameters,sizeof(ULONG_PTR)*NumberOfParameters);
|
|
|
|
|
|
// probe all strings
|
|
if ( UnicodeStringParameterMask ) {
|
|
for(Counter=0;Counter < NumberOfParameters;Counter++){
|
|
// if there is a string in this position,
|
|
// then probe and capture the string
|
|
if ( UnicodeStringParameterMask & (1<<Counter) ) {
|
|
ProbeForRead((PVOID)CapturedParameters[Counter], sizeof(UNICODE_STRING), sizeof(ULONG_PTR));
|
|
RtlMoveMemory(&CapturedString, (PVOID)CapturedParameters[Counter], sizeof(UNICODE_STRING));
|
|
|
|
// Now probe the string
|
|
ProbeForRead(CapturedString.Buffer, CapturedString.MaximumLength, sizeof(UCHAR));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
CapturedParameters = NULL;
|
|
}
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER) {
|
|
if ( CapturedParameters ) {
|
|
ExFreePool(CapturedParameters);
|
|
}
|
|
return GetExceptionCode();
|
|
}
|
|
|
|
if (ErrorStatus == STATUS_SYSTEM_IMAGE_BAD_SIGNATURE && KdDebuggerEnabled) {
|
|
if (NumberOfParameters && CapturedParameters) {
|
|
DbgPrint("****************************************************************\n");
|
|
DbgPrint("* The system detected a bad signature on file %wZ\n",(PUNICODE_STRING)CapturedParameters[0]);
|
|
DbgPrint("****************************************************************\n");
|
|
}
|
|
if (CapturedParameters) {
|
|
ExFreePool(CapturedParameters);
|
|
}
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
// Call ExpRaiseHardError. All parameters are probed and everything
|
|
// should be user-mode.
|
|
// ExRaiseHardError will squirt all strings into user-mode
|
|
// without any probing
|
|
Status = ExpRaiseHardError(ErrorStatus, NumberOfParameters, UnicodeStringParameterMask, CapturedParameters, ValidResponseOptions, &LocalResponse);
|
|
}
|
|
else {
|
|
CapturedParameters = Parameters;
|
|
|
|
Status = ExRaiseHardError(ErrorStatus, NumberOfParameters, UnicodeStringParameterMask, CapturedParameters, ValidResponseOptions, &LocalResponse);
|
|
}
|
|
|
|
if (PreviousMode != KernelMode) {
|
|
if ( CapturedParameters ) {
|
|
ExFreePool(CapturedParameters);
|
|
}
|
|
try {
|
|
*Response = LocalResponse;
|
|
}
|
|
except (EXCEPTION_EXECUTE_HANDLER) {
|
|
return Status;
|
|
}
|
|
}
|
|
else {
|
|
*Response = LocalResponse;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ExRaiseHardError(
|
|
IN NTSTATUS ErrorStatus,
|
|
IN ULONG NumberOfParameters,
|
|
IN ULONG UnicodeStringParameterMask,
|
|
IN PULONG_PTR Parameters,
|
|
IN ULONG ValidResponseOptions,
|
|
OUT PULONG Response
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
PULONG_PTR ParameterBlock;
|
|
PULONG_PTR UserModeParameterBase;
|
|
PUNICODE_STRING UserModeStringsBase;
|
|
PUCHAR UserModeStringDataBase;
|
|
UNICODE_STRING CapturedStrings[MAXIMUM_HARDERROR_PARAMETERS];
|
|
ULONG LocalResponse;
|
|
ULONG Counter;
|
|
SIZE_T UserModeSize;
|
|
|
|
PAGED_CODE();
|
|
|
|
|
|
// If we are in the process of shuting down the system, do not allow
|
|
// hard errors.
|
|
|
|
|
|
if ( ExpTooLateForErrors ) {
|
|
|
|
*Response = ResponseNotHandled;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
// If the parameters contain strings, we need to capture
|
|
// the strings and the string descriptors and push them into
|
|
// user-mode.
|
|
|
|
|
|
if ( ARGUMENT_PRESENT(Parameters) ) {
|
|
if ( UnicodeStringParameterMask ) {
|
|
|
|
|
|
// We have strings. The parameter block and all strings
|
|
// must be pushed into usermode.
|
|
|
|
|
|
UserModeSize = (sizeof(ULONG_PTR)+sizeof(UNICODE_STRING))*MAXIMUM_HARDERROR_PARAMETERS;
|
|
UserModeSize += sizeof(UNICODE_STRING);
|
|
|
|
for(Counter=0;Counter < NumberOfParameters;Counter++){
|
|
|
|
|
|
// if there is a string in this position,
|
|
// then probe and capture the string
|
|
|
|
|
|
if ( UnicodeStringParameterMask & 1<<Counter ) {
|
|
|
|
RtlMoveMemory(
|
|
&CapturedStrings[Counter],
|
|
(PVOID)Parameters[Counter],
|
|
sizeof(UNICODE_STRING)
|
|
);
|
|
|
|
UserModeSize += CapturedStrings[Counter].MaximumLength;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
// Now we have the user-mode size all figured out.
|
|
// Allocate some memory and point to it with the
|
|
// parameter block. Then go through and copy all
|
|
// of the parameters, string descriptors, and
|
|
// string data into the memory
|
|
|
|
|
|
ParameterBlock = NULL;
|
|
Status = ZwAllocateVirtualMemory(
|
|
NtCurrentProcess(),
|
|
(PVOID *)&ParameterBlock,
|
|
0,
|
|
&UserModeSize,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE
|
|
);
|
|
|
|
if (!NT_SUCCESS( Status )) {
|
|
return( Status );
|
|
}
|
|
|
|
UserModeParameterBase = ParameterBlock;
|
|
UserModeStringsBase = (PUNICODE_STRING)((PUCHAR)ParameterBlock + sizeof(ULONG)*MAXIMUM_HARDERROR_PARAMETERS);
|
|
UserModeStringDataBase = (PUCHAR)UserModeStringsBase + sizeof(UNICODE_STRING)*MAXIMUM_HARDERROR_PARAMETERS;
|
|
|
|
for(Counter=0;Counter < NumberOfParameters;Counter++){
|
|
|
|
|
|
// move parameters to user-mode portion of the
|
|
// address space.
|
|
|
|
|
|
if ( UnicodeStringParameterMask & 1<<Counter ) {
|
|
|
|
|
|
// fix the parameter to point at the string descriptor slot
|
|
// in the user-mode buffer.
|
|
|
|
|
|
UserModeParameterBase[Counter] = (ULONG_PTR)&UserModeStringsBase[Counter];
|
|
|
|
|
|
// Copy the string data to user-mode
|
|
|
|
|
|
RtlMoveMemory(
|
|
UserModeStringDataBase,
|
|
CapturedStrings[Counter].Buffer,
|
|
CapturedStrings[Counter].MaximumLength
|
|
);
|
|
|
|
CapturedStrings[Counter].Buffer = (PWSTR)UserModeStringDataBase;
|
|
|
|
|
|
// copy the string descriptor
|
|
|
|
|
|
RtlMoveMemory(
|
|
&UserModeStringsBase[Counter],
|
|
&CapturedStrings[Counter],
|
|
sizeof(UNICODE_STRING)
|
|
);
|
|
|
|
|
|
// Adjust the string data base
|
|
|
|
|
|
UserModeStringDataBase += CapturedStrings[Counter].MaximumLength;
|
|
|
|
}
|
|
else {
|
|
UserModeParameterBase[Counter] = Parameters[Counter];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
ParameterBlock = Parameters;
|
|
}
|
|
}
|
|
else {
|
|
ParameterBlock = NULL;
|
|
}
|
|
|
|
|
|
// Call the hard error sender.
|
|
|
|
|
|
Status = ExpRaiseHardError(
|
|
ErrorStatus,
|
|
NumberOfParameters,
|
|
UnicodeStringParameterMask,
|
|
ParameterBlock,
|
|
ValidResponseOptions,
|
|
&LocalResponse
|
|
);
|
|
|
|
// If the parameter block was allocated, it needs to be
|
|
// freed
|
|
|
|
|
|
if ( ParameterBlock && ParameterBlock != Parameters ) {
|
|
UserModeSize = 0;
|
|
ZwFreeVirtualMemory(
|
|
NtCurrentProcess(),
|
|
(PVOID *)&ParameterBlock,
|
|
&UserModeSize,
|
|
MEM_RELEASE
|
|
);
|
|
}
|
|
*Response = LocalResponse;
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NtSetDefaultHardErrorPort(
|
|
IN HANDLE DefaultHardErrorPort
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
PAGED_CODE();
|
|
|
|
if (!SeSinglePrivilegeCheck( SeTcbPrivilege, KeGetPreviousMode() )) {
|
|
return STATUS_PRIVILEGE_NOT_HELD;
|
|
}
|
|
|
|
if ( ExReadyForErrors ) {
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
|
|
// Priv check ?
|
|
|
|
|
|
Status = ObReferenceObjectByHandle (
|
|
DefaultHardErrorPort,
|
|
0,
|
|
LpcPortObjectType,
|
|
KeGetPreviousMode(),
|
|
(PVOID *)&ExpDefaultErrorPort,
|
|
NULL
|
|
);
|
|
if ( !NT_SUCCESS(Status) ) {
|
|
return Status;
|
|
}
|
|
|
|
ExReadyForErrors = TRUE;
|
|
ExpDefaultErrorPortProcess = PsGetCurrentProcess();
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
__cdecl
|
|
_purecall()
|
|
{
|
|
ASSERTMSG("_purecall() was called", FALSE);
|
|
ExRaiseStatus(STATUS_NOT_IMPLEMENTED);
|
|
}
|