reactos/ntoskrnl/ex/harderr.c
Timo Kreuzer 9ea495ba33 Create a branch for header work.
svn path=/branches/header-work/; revision=45691
2010-02-26 22:57:55 +00:00

768 lines
22 KiB
C

/*
* PROJECT: ReactOS Kernel
* LICENSE: GPL - See COPYING in the top level directory
* FILE: ntoskrnl/ex/error.c
* PURPOSE: Error Functions and Status/Exception Dispatching/Raising
* PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
*/
/* INCLUDES *****************************************************************/
#include <ntoskrnl.h>
#define NDEBUG
#include <debug.h>
#define TAG_ERR ' rrE'
/* GLOBALS ****************************************************************/
BOOLEAN ExReadyForErrors = FALSE;
PVOID ExpDefaultErrorPort = NULL;
PEPROCESS ExpDefaultErrorPortProcess = NULL;
/* FUNCTIONS ****************************************************************/
/*++
* @name ExpSystemErrorHandler
*
* For now it's a stub
*
* @param ErrorStatus
* FILLME
*
* @param NumberOfParameters
* FILLME
*
* @param UnicodeStringParameterMask
* FILLME
*
* @param Parameters
* FILLME
*
* @param ValidResponseOptions
* FILLME
*
* @param Response
* FILLME
*
* @return None
*
* @remarks None
*
*--*/
NTSTATUS
NTAPI
ExpSystemErrorHandler(IN NTSTATUS ErrorStatus,
IN ULONG NumberOfParameters,
IN ULONG UnicodeStringParameterMask,
IN PULONG_PTR Parameters,
IN BOOLEAN Shutdown)
{
ULONG_PTR BugCheckParameters[MAXIMUM_HARDERROR_PARAMETERS] = {0, 0, 0, 0};
ULONG i;
/* Sanity check */
ASSERT(NumberOfParameters <= MAXIMUM_HARDERROR_PARAMETERS);
/*
* KeBugCheck expects MAXIMUM_HARDERROR_PARAMETERS parameters,
* but we might get called with less, so use a local buffer here.
*/
for (i = 0; i < NumberOfParameters; i++)
{
/* Copy them over */
BugCheckParameters[i] = Parameters[i];
}
/* FIXME: STUB */
KeBugCheckEx(FATAL_UNHANDLED_HARD_ERROR,
ErrorStatus,
(ULONG_PTR)BugCheckParameters,
0,
0);
return STATUS_SUCCESS;
}
/*++
* @name ExpRaiseHardError
*
* For now it's a stub
*
* @param ErrorStatus
* FILLME
*
* @param NumberOfParameters
* FILLME
*
* @param UnicodeStringParameterMask
* FILLME
*
* @param Parameters
* FILLME
*
* @param ValidResponseOptions
* FILLME
*
* @param Response
* FILLME
*
* @return None
*
* @remarks None
*
*--*/
NTSTATUS
NTAPI
ExpRaiseHardError(IN NTSTATUS ErrorStatus,
IN ULONG NumberOfParameters,
IN ULONG UnicodeStringParameterMask,
IN PULONG_PTR Parameters,
IN ULONG ValidResponseOptions,
OUT PULONG Response)
{
PEPROCESS Process = PsGetCurrentProcess();
PETHREAD Thread = PsGetCurrentThread();
UCHAR Buffer[PORT_MAXIMUM_MESSAGE_LENGTH];
PHARDERROR_MSG Message = (PHARDERROR_MSG)Buffer;
NTSTATUS Status;
HANDLE PortHandle;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
PAGED_CODE();
/* Check if this error will shutdown the system */
if (ValidResponseOptions == OptionShutdownSystem)
{
/* Check for privilege */
if (!SeSinglePrivilegeCheck(SeShutdownPrivilege, PreviousMode))
{
/* No rights */
return STATUS_PRIVILEGE_NOT_HELD;
}
/* Don't handle any new hard errors */
ExReadyForErrors = FALSE;
}
/* Check if hard errors are not disabled */
if (!Thread->HardErrorsAreDisabled)
{
/* Check if we can't do errors anymore, and this is serious */
if ((!ExReadyForErrors) && (NT_ERROR(ErrorStatus)))
{
/* Use the system handler */
ExpSystemErrorHandler(ErrorStatus,
NumberOfParameters,
UnicodeStringParameterMask,
Parameters,
(PreviousMode != KernelMode) ? TRUE: FALSE);
}
}
/* Check if we have an exception port */
if (Process->ExceptionPort)
{
/* Check if hard errors should be processed */
if (Process->DefaultHardErrorProcessing & 1)
{
/* Use the port */
PortHandle = Process->ExceptionPort;
}
else
{
/* It's disabled, check if the error overrides it */
if (ErrorStatus & 0x10000000)
{
/* Use the port anyway */
PortHandle = Process->ExceptionPort;
}
else
{
/* No such luck */
PortHandle = NULL;
}
}
}
else
{
/* Check if hard errors are enabled */
if (Process->DefaultHardErrorProcessing & 1)
{
/* Use our default system port */
PortHandle = ExpDefaultErrorPort;
}
else
{
/* It's disabled, check if the error overrides it */
if (ErrorStatus & 0x10000000)
{
/* Use the port anyway */
PortHandle = ExpDefaultErrorPort;
}
else
{
/* No such luck */
PortHandle = NULL;
}
}
}
/* If hard errors are disabled, do nothing */
if (Thread->HardErrorsAreDisabled) PortHandle = NULL;
/* Now check if we have a port */
if (PortHandle)
{
/* Check if this is the default process */
if (Process == ExpDefaultErrorPortProcess)
{
/* We can't handle the error, check if this is critical */
if (NT_ERROR(ErrorStatus))
{
/* It is, invoke the system handler */
ExpSystemErrorHandler(ErrorStatus,
NumberOfParameters,
UnicodeStringParameterMask,
Parameters,
(PreviousMode != KernelMode) ? TRUE: FALSE);
/* If we survived, return to caller */
*Response = ResponseReturnToCaller;
return STATUS_SUCCESS;
}
}
/* Setup the LPC Message */
Message->h.u1.Length = (sizeof(HARDERROR_MSG) << 16) |
(sizeof(HARDERROR_MSG) - sizeof(PORT_MESSAGE));
Message->h.u2.ZeroInit = 0;
Message->h.u2.s2.Type = LPC_ERROR_EVENT;
Message->Status = ErrorStatus &~ 0x10000000;
Message->ValidResponseOptions = ValidResponseOptions;
Message->UnicodeStringParameterMask = UnicodeStringParameterMask;
Message->NumberOfParameters = NumberOfParameters;
KeQuerySystemTime(&Message->ErrorTime);
/* Copy the parameters */
if (Parameters) RtlMoveMemory(&Message->Parameters,
Parameters,
sizeof(ULONG_PTR) * NumberOfParameters);
/* Send the LPC Message */
Status = LpcRequestWaitReplyPort(PortHandle,
(PVOID)Message,
(PVOID)Message);
if (NT_SUCCESS(Status))
{
/* Check what kind of response we got */
if ((Message->Response != ResponseReturnToCaller) &&
(Message->Response != ResponseNotHandled) &&
(Message->Response != ResponseAbort) &&
(Message->Response != ResponseCancel) &&
(Message->Response != ResponseIgnore) &&
(Message->Response != ResponseNo) &&
(Message->Response != ResponseOk) &&
(Message->Response != ResponseRetry) &&
(Message->Response != ResponseYes) &&
(Message->Response != ResponseTryAgain) &&
(Message->Response != ResponseContinue))
{
/* Reset to a default one */
Message->Response = ResponseReturnToCaller;
}
/* Set the response */
*Response = Message->Response;
}
}
else
{
/* Set defaults */
*Response = ResponseReturnToCaller;
Status = STATUS_SUCCESS;
}
/* Return status */
return Status;
}
/*++
* @name ExRaiseAccessViolation
* @implemented
*
* The ExRaiseAccessViolation routine can be used with structured exception
* handling to throw a driver-determined exception for a memory access
* violation that occurs when a driver processes I/O requests.
* See: http://msdn.microsoft.com/library/en-us/Kernel_r/hh/Kernel_r/k102_71b4c053-599c-4a6d-8a59-08aae6bdc534.xml.asp?frame=true
* http://www.osronline.com/ddkx/kmarch/k102_814i.htm
*
* @return None
*
* @remarks None
*
*--*/
VOID
NTAPI
ExRaiseAccessViolation(VOID)
{
/* Raise the Right Status */
RtlRaiseStatus(STATUS_ACCESS_VIOLATION);
}
/*++
* @name ExRaiseDatatypeMisalignment
* @implemented
*
* ExRaiseDatatypeMisalignment raises an exception with the exception
* code set to STATUS_DATATYPE_MISALIGNMENT
* See: MSDN / DDK
* http://www.osronline.com/ddkx/kmarch/k102_814i.htm
*
* @return None
*
* @remarks None
*
*--*/
VOID
NTAPI
ExRaiseDatatypeMisalignment(VOID)
{
/* Raise the Right Status */
RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
}
/*++
* @name ExSystemExceptionFilter
* @implemented
*
* TODO: Add description
*
* @return FILLME
*
* @remarks None
*
*--*/
LONG
NTAPI
ExSystemExceptionFilter(VOID)
{
return KeGetPreviousMode() != KernelMode ?
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
}
/*++
* @name ExRaiseHardError
* @implemented
*
* See NtRaiseHardError
*
* @param ErrorStatus
* Error Code
*
* @param NumberOfParameters
* Number of optional parameters in Parameters array
*
* @param UnicodeStringParameterMask
* Optional string parameter (can be only one per error code)
*
* @param Parameters
* Array of ULONG parameters for use in error message string
*
* @param ValidResponseOptions
* See HARDERROR_RESPONSE_OPTION for possible values description
*
* @param Response
* Pointer to HARDERROR_RESPONSE enumeration
*
* @return None
*
* @remarks None
*
*--*/
NTSTATUS
NTAPI
ExRaiseHardError(IN NTSTATUS ErrorStatus,
IN ULONG NumberOfParameters,
IN ULONG UnicodeStringParameterMask,
IN PULONG_PTR Parameters,
IN ULONG ValidResponseOptions,
OUT PULONG Response)
{
SIZE_T Size;
UNICODE_STRING CapturedParams[MAXIMUM_HARDERROR_PARAMETERS];
ULONG i;
PULONG_PTR UserData = NULL, ParameterBase;
PUNICODE_STRING StringBase;
PWSTR BufferBase;
ULONG SafeResponse;
NTSTATUS Status;
PAGED_CODE();
/* Check if we have parameters */
if (Parameters)
{
/* Check if we have strings */
if (UnicodeStringParameterMask)
{
/* Add the maximum possible size */
Size = (sizeof(ULONG_PTR) + sizeof(UNICODE_STRING)) *
MAXIMUM_HARDERROR_PARAMETERS + sizeof(UNICODE_STRING);
/* Loop each parameter */
for (i = 0; i < NumberOfParameters; i++)
{
/* Check if it's part of the mask */
if (UnicodeStringParameterMask & (1 << i))
{
/* Copy it */
RtlMoveMemory(&CapturedParams[i],
&Parameters[i],
sizeof(UNICODE_STRING));
/* Increase the size */
Size += CapturedParams[i].MaximumLength;
}
}
/* Allocate the user data region */
Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
(PVOID*)&UserData,
0,
&Size,
MEM_COMMIT,
PAGE_READWRITE);
if (!NT_SUCCESS(Status)) return Status;
/* Set the pointers to our various data */
ParameterBase = UserData;
StringBase = (PVOID)((ULONG_PTR)UserData +
sizeof(ULONG_PTR) *
MAXIMUM_HARDERROR_PARAMETERS);
BufferBase = (PVOID)((ULONG_PTR)StringBase +
sizeof(UNICODE_STRING) *
MAXIMUM_HARDERROR_PARAMETERS);
/* Loop parameters again */
for (i = 0; i < NumberOfParameters; i++)
{
/* Check if we're in the mask */
if (UnicodeStringParameterMask & (1 << i))
{
/* Update the base */
ParameterBase[i] = (ULONG_PTR)&StringBase[i];
/* Copy the string buffer */
RtlMoveMemory(BufferBase,
CapturedParams[i].Buffer,
CapturedParams[i].MaximumLength);
/* Set buffer */
CapturedParams[i].Buffer = BufferBase;
/* Copy the string structure */
RtlMoveMemory(&StringBase[i],
&CapturedParams[i],
sizeof(UNICODE_STRING));
/* Update the pointer */
BufferBase += CapturedParams[i].MaximumLength;
}
else
{
/* No need to copy any strings */
ParameterBase[i] = Parameters[i];
}
}
}
else
{
/* Just keep the data as is */
UserData = Parameters;
}
}
/* Now call the worker function */
Status = ExpRaiseHardError(ErrorStatus,
NumberOfParameters,
UnicodeStringParameterMask,
UserData,
ValidResponseOptions,
&SafeResponse);
/* Check if we had done user-mode allocation */
if ((UserData) && (UserData != Parameters))
{
/* We did! Delete it */
Size = 0;
ZwFreeVirtualMemory(NtCurrentProcess(),
(PVOID*)&UserData,
&Size,
MEM_RELEASE);
}
/* Return status and the response */
*Response = SafeResponse;
return Status;
}
/*++
* @name NtRaiseHardError
* @implemented
*
* This function sends HARDERROR_MSG LPC message to listener
* (typically CSRSS.EXE). See NtSetDefaultHardErrorPort for more information
* See: http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Error/NtRaiseHardError.html
*
* @param ErrorStatus
* Error Code
*
* @param NumberOfParameters
* Number of optional parameters in Parameters array
*
* @param UnicodeStringParameterMask
* Optional string parameter (can be only one per error code)
*
* @param Parameters
* Array of ULONG_PTR parameters for use in error message string
*
* @param ValidResponseOptions
* See HARDERROR_RESPONSE_OPTION for possible values description
*
* @param Response
* Pointer to HARDERROR_RESPONSE enumeration
*
* @return Status
*
* @remarks NtRaiseHardError is easy way to display message in GUI
* without loading Win32 API libraries
*
*--*/
NTSTATUS
NTAPI
NtRaiseHardError(IN NTSTATUS ErrorStatus,
IN ULONG NumberOfParameters,
IN ULONG UnicodeStringParameterMask,
IN PULONG_PTR Parameters,
IN ULONG ValidResponseOptions,
OUT PULONG Response)
{
NTSTATUS Status = STATUS_SUCCESS;
PULONG_PTR SafeParams = NULL;
ULONG SafeResponse;
UNICODE_STRING SafeString;
ULONG i;
ULONG ParamSize;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
/* Validate parameter count */
if (NumberOfParameters > MAXIMUM_HARDERROR_PARAMETERS)
{
/* Fail */
return STATUS_INVALID_PARAMETER_2;
}
/* Make sure we have some at least */
if ((Parameters) && !(NumberOfParameters))
{
/* Fail */
return STATUS_INVALID_PARAMETER_2;
}
/* Check if we were called from user-mode */
if (PreviousMode != KernelMode)
{
/* First validate the responses */
switch (ValidResponseOptions)
{
/* Check all valid cases */
case OptionAbortRetryIgnore:
case OptionOk:
case OptionOkCancel:
case OptionRetryCancel:
case OptionYesNo:
case OptionYesNoCancel:
case OptionShutdownSystem:
break;
/* Anything else is invalid */
default:
return STATUS_INVALID_PARAMETER_4;
}
/* Enter SEH Block */
_SEH2_TRY
{
/* Validate the response pointer */
ProbeForWriteUlong(Response);
/* Check if we have parameters */
if (Parameters)
{
/* Validate the parameter pointers */
ParamSize = sizeof(ULONG_PTR) * NumberOfParameters;
ProbeForRead(Parameters, ParamSize, sizeof(ULONG_PTR));
/* Allocate a safe buffer */
SafeParams = ExAllocatePoolWithTag(PagedPool,
ParamSize,
TAG_ERR);
/* Copy them */
RtlCopyMemory(SafeParams, Parameters, ParamSize);
/* Nowo check if there's strings in it */
if (UnicodeStringParameterMask)
{
/* Loop every string */
for (i = 0; i < NumberOfParameters; i++)
{
/* Check if this parameter is a string */
if (UnicodeStringParameterMask & (1 << i))
{
/* Probe the structure */
ProbeForRead((PVOID)SafeParams[i],
sizeof(UNICODE_STRING),
sizeof(ULONG_PTR));
/* Capture it */
RtlCopyMemory(&SafeString,
(PVOID)SafeParams[i],
sizeof(UNICODE_STRING));
/* Probe the buffer */
ProbeForRead(SafeString.Buffer,
SafeString.MaximumLength,
sizeof(UCHAR));
}
}
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Free captured buffer */
if (SafeParams) ExFreePool(SafeParams);
/* Return the exception code */
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
/* Call the system function directly, because we probed */
ExpRaiseHardError(ErrorStatus,
NumberOfParameters,
UnicodeStringParameterMask,
SafeParams,
ValidResponseOptions,
&SafeResponse);
}
else
{
/* Reuse variable */
SafeParams = Parameters;
/*
* Call the Executive Function. It will probe and copy pointers to
* user-mode
*/
ExRaiseHardError(ErrorStatus,
NumberOfParameters,
UnicodeStringParameterMask,
SafeParams,
ValidResponseOptions,
&SafeResponse);
}
/* Check if we were called in user-mode */
if (PreviousMode != KernelMode)
{
/* That means we have a buffer to free */
if (SafeParams) ExFreePool(SafeParams);
/* Enter SEH Block for return */
_SEH2_TRY
{
/* Return the response */
*Response = SafeResponse;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
}
else
{
/* Return the response */
*Response = SafeResponse;
}
/* Return status */
return Status;
}
/*++
* @name NtSetDefaultHardErrorPort
* @implemented
*
* NtSetDefaultHardErrorPort is typically called only once. After call,
* kernel set BOOLEAN flag named _ExReadyForErrors to TRUE, and all other
* tries to change default port are broken with STATUS_UNSUCCESSFUL error code
* See: http://www.windowsitlibrary.com/Content/356/08/2.html
* http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Error/NtSetDefaultHardErrorPort.html
*
* @param PortHandle
* Handle to named port object
*
* @return Status
*
* @remarks Privileges: SE_TCB_PRIVILEGE
*
*--*/
NTSTATUS
NTAPI
NtSetDefaultHardErrorPort(IN HANDLE PortHandle)
{
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
NTSTATUS Status = STATUS_UNSUCCESSFUL;
/* Check if we have the Privilege */
if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
{
DPRINT1("NtSetDefaultHardErrorPort: Caller requires "
"the SeTcbPrivilege privilege!\n");
return STATUS_PRIVILEGE_NOT_HELD;
}
/* Only called once during bootup, make sure we weren't called yet */
if (!ExReadyForErrors)
{
/* Reference the port */
Status = ObReferenceObjectByHandle(PortHandle,
0,
LpcPortObjectType,
PreviousMode,
(PVOID*)&ExpDefaultErrorPort,
NULL);
if (NT_SUCCESS(Status))
{
/* Save the data */
ExpDefaultErrorPortProcess = PsGetCurrentProcess();
ExReadyForErrors = TRUE;
}
}
/* Return status to caller */
return Status;
}
VOID
__cdecl
_purecall(VOID)
{
/* Not supported in Kernel Mode */
RtlRaiseStatus(STATUS_NOT_IMPLEMENTED);
}
/* EOF */