00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
#include "exp.h"
00022
00023 extern ULONG
KiBugCheckData[5];
00024 extern ULONG
KeBugCheckCount;
00025
00026
NTSTATUS
00027
ExpRaiseHardError(
00028 IN NTSTATUS ErrorStatus,
00029 IN ULONG NumberOfParameters,
00030 IN ULONG UnicodeStringParameterMask,
00031 IN PULONG_PTR Parameters,
00032 IN ULONG ValidResponseOptions,
00033 OUT PULONG Response
00034 );
00035
00036
VOID
00037
ExpSystemErrorHandler(
00038 IN NTSTATUS ErrorStatus,
00039 IN ULONG NumberOfParameters,
00040 IN ULONG UnicodeStringParameterMask,
00041 IN PULONG_PTR Parameters,
00042 IN BOOLEAN CallShutdown
00043 );
00044
00045
#if defined(ALLOC_PRAGMA)
00046
#pragma alloc_text(PAGE, NtRaiseHardError)
00047
#pragma alloc_text(PAGE, NtSetDefaultHardErrorPort)
00048
#pragma alloc_text(PAGE, ExRaiseHardError)
00049
#pragma alloc_text(PAGE, ExpRaiseHardError)
00050
#pragma alloc_text(PAGELK, ExpSystemErrorHandler)
00051
#endif
00052
00053 #define HARDERROR_MSG_OVERHEAD (sizeof(HARDERROR_MSG) - sizeof(PORT_MESSAGE))
00054 #define HARDERROR_API_MSG_LENGTH \
00055
sizeof(HARDERROR_MSG)<<16 | (HARDERROR_MSG_OVERHEAD)
00056
00057 PEPROCESS ExpDefaultErrorPortProcess;
00058 BOOLEAN
ExReadyForErrors =
FALSE;
00059 BOOLEAN
ExpTooLateForErrors =
FALSE;
00060 HANDLE
ExpDefaultErrorPort;
00061 extern PVOID
PsSystemDllDllBase;
00062
00063
VOID
00064 ExpSystemErrorHandler(
00065 IN NTSTATUS ErrorStatus,
00066 IN ULONG NumberOfParameters,
00067 IN ULONG UnicodeStringParameterMask,
00068 IN PULONG_PTR Parameters,
00069 IN BOOLEAN CallShutdown
00070 )
00071 {
00072
00073 ULONG Counter;
00074 ANSI_STRING AnsiString;
00075
NTSTATUS Status;
00076 ULONG_PTR ParameterVector[MAXIMUM_HARDERROR_PARAMETERS];
00077
CHAR DefaultFormatBuffer[32];
00078
CHAR ExpSystemErrorBuffer[256];
00079 PMESSAGE_RESOURCE_ENTRY MessageEntry;
00080 PSZ ErrorCaption;
00081 PSZ ErrorFormatString;
00082 ANSI_STRING Astr;
00083 UNICODE_STRING Ustr;
00084 OEM_STRING Ostr;
00085 PSZ OemCaption;
00086 PSZ OemMessage;
00087 PSZ UnknownHardError =
"Unknown Hard Error";
00088 PVOID UnlockHandle;
00089 CONTEXT ContextSave;
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108 RtlCaptureContext(&
KeGetCurrentPrcb()->ProcessorState.ContextFrame);
00109
KiSaveProcessorControlState(&
KeGetCurrentPrcb()->ProcessorState);
00110 ContextSave =
KeGetCurrentPrcb()->ProcessorState.ContextFrame;
00111
00112
00113 DefaultFormatBuffer[0] =
'\0';
00114 RtlZeroMemory(ParameterVector,
sizeof(ParameterVector));
00115
for(Counter=0;Counter < NumberOfParameters;Counter++){
00116 ParameterVector[Counter] = Parameters[Counter];
00117 }
00118
00119
for(Counter=0;Counter < NumberOfParameters;Counter++){
00120
if ( UnicodeStringParameterMask & 1<<Counter ) {
00121 strcat(DefaultFormatBuffer,
" %s");
00122
RtlUnicodeStringToAnsiString(&AnsiString,(PUNICODE_STRING)Parameters[Counter],
TRUE);
00123 ParameterVector[Counter] = (ULONG_PTR)AnsiString.Buffer;
00124 }
00125
else {
00126 strcat(DefaultFormatBuffer,
" %x");
00127 }
00128 }
00129 strcat(DefaultFormatBuffer,
"\n");
00130
00131
00132
00133
00134
00135
if (
PsSystemDllDllBase ) {
00136
00137
try {
00138
00139
00140
00141
00142
00143
00144
00145
Status =
RtlFindMessage(
PsSystemDllDllBase,
00146 11,
00147
NlsMbCodePageTag ?
00148 MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US) :
00149 0,
00150 ErrorStatus,
00151 &MessageEntry);
00152
00153
if (!
NT_SUCCESS(
Status)) {
00154 ErrorCaption = ErrorFormatString = UnknownHardError;
00155 }
00156
else {
00157
if (MessageEntry->Flags & MESSAGE_RESOURCE_UNICODE) {
00158
00159
00160
00161
00162
00163
RtlInitUnicodeString(&Ustr, (PCWSTR)MessageEntry->Text);
00164 Astr.Length = (
USHORT) RtlUnicodeStringToAnsiSize(&Ustr);
00165 ErrorCaption =
ExAllocatePoolWithTag(
NonPagedPool,Astr.Length+16, ' rrE');
00166
00167
if (ErrorCaption) {
00168 Astr.MaximumLength = Astr.Length + 16;
00169 Astr.Buffer = ErrorCaption;
00170
Status =
RtlUnicodeStringToAnsiString(&Astr, &Ustr,
FALSE);
00171
if ( !
NT_SUCCESS(
Status) ) {
00172
ExFreePool(ErrorCaption);
00173 ErrorCaption = ErrorFormatString = UnknownHardError;
00174 }
00175 }
00176
else {
00177 ErrorCaption = ErrorFormatString = UnknownHardError;
00178 }
00179
00180 }
00181
else {
00182 ErrorCaption =
ExAllocatePoolWithTag(
NonPagedPool,
strlen(MessageEntry->Text)+16, ' rrE');
00183
if ( ErrorCaption ) {
00184 strcpy(ErrorCaption,MessageEntry->Text);
00185 }
00186
else {
00187 ErrorCaption = ErrorFormatString = UnknownHardError;
00188 }
00189 }
00190
00191
if (ErrorCaption != UnknownHardError) {
00192
00193
00194
00195
00196 ErrorFormatString = ErrorCaption;
00197 Counter =
strlen(ErrorCaption);
00198
while ( Counter && *ErrorFormatString >=
' ' ) {
00199 ErrorFormatString++;
00200 Counter--;
00201 }
00202
00203 *ErrorFormatString++ =
'\0';
00204 Counter--;
00205
00206
while ( Counter && *ErrorFormatString && *ErrorFormatString <=
' ') {
00207 ErrorFormatString++;
00208 Counter--;
00209 }
00210 }
00211
00212
if (!Counter) {
00213
00214 ErrorFormatString =
"";
00215 }
00216 }
00217 }
00218 except (
EXCEPTION_EXECUTE_HANDLER ) {
00219 ErrorFormatString = UnknownHardError;
00220 ErrorCaption = UnknownHardError;
00221 }
00222 }
00223
else {
00224 ErrorFormatString = DefaultFormatBuffer;
00225 ErrorCaption = UnknownHardError;
00226 }
00227
00228
try {
00229 _snprintf( ExpSystemErrorBuffer,
sizeof( ExpSystemErrorBuffer ),
00230
"\nSTOP: %lx %s\n", ErrorStatus,ErrorCaption);
00231 }
00232 except(
EXCEPTION_EXECUTE_HANDLER) {
00233 _snprintf( ExpSystemErrorBuffer,
sizeof( ExpSystemErrorBuffer ),
00234
"\nHardError %lx\n", ErrorStatus);
00235 }
00236
00237 UnlockHandle = MmLockPagableCodeSection((PVOID)
ExpSystemErrorHandler);
00238
ASSERT(UnlockHandle);
00239
00240
00241
00242
00243
00244 OemCaption = UnknownHardError;
00245 OemMessage = UnknownHardError;
00246
00247
RtlInitAnsiString(&Astr,ExpSystemErrorBuffer);
00248
Status =
RtlAnsiStringToUnicodeString(&Ustr,&Astr,
TRUE);
00249
if ( !
NT_SUCCESS(
Status) ) {
00250
goto punt1;
00251 }
00252
00253
00254
00255
00256
00257 Ostr.Length = (
USHORT)RtlUnicodeStringToOemSize(&Ustr);
00258 Ostr.MaximumLength = Ostr.Length;
00259 Ostr.Buffer =
ExAllocatePoolWithTag(
NonPagedPool, Ostr.Length, ' rrE');
00260 OemCaption = Ostr.Buffer;
00261
if (Ostr.Buffer) {
00262
Status =
RtlUnicodeStringToOemString(&Ostr,&Ustr,
FALSE);
00263
if ( !
NT_SUCCESS(
Status) ) {
00264
goto punt1;
00265 }
00266 }
00267
00268
00269
00270
00271
00272 punt1:;
00273
try {
00274 _snprintf( ExpSystemErrorBuffer,
sizeof( ExpSystemErrorBuffer ),
00275 ErrorFormatString,
00276 ParameterVector[0],
00277 ParameterVector[1],
00278 ParameterVector[2],
00279 ParameterVector[3]
00280 );
00281 }
00282 except(
EXCEPTION_EXECUTE_HANDLER) {
00283 _snprintf( ExpSystemErrorBuffer,
sizeof( ExpSystemErrorBuffer ),
00284
"Exception Processing Message %lx Parameters %lx %lx %lx %lx",
00285 ErrorStatus,
00286 ParameterVector[0],
00287 ParameterVector[1],
00288 ParameterVector[2],
00289 ParameterVector[3]
00290 );
00291 }
00292
00293
00294
RtlInitAnsiString(&Astr,ExpSystemErrorBuffer);
00295
Status =
RtlAnsiStringToUnicodeString(&Ustr,&Astr,
TRUE);
00296
if ( !
NT_SUCCESS(
Status) ) {
00297
goto punt2;
00298 }
00299
00300
00301
00302
00303 Ostr.Length = (
USHORT)RtlUnicodeStringToOemSize(&Ustr);
00304 Ostr.MaximumLength = Ostr.Length;
00305 Ostr.Buffer =
ExAllocatePoolWithTag(
NonPagedPool, Ostr.Length, ' rrE');
00306 OemMessage = Ostr.Buffer;
00307
if (Ostr.Buffer) {
00308
Status =
RtlUnicodeStringToOemString(&Ostr,&Ustr,
FALSE);
00309
if ( !
NT_SUCCESS(
Status) ) {
00310
goto punt2;
00311 }
00312 }
00313
00314 punt2:;
00315
ASSERT(
sizeof(PVOID) ==
sizeof(ULONG_PTR));
00316
ASSERT(
sizeof(ULONG) ==
sizeof(
NTSTATUS));
00317
00318
00319
00320
00321
00322
if (CallShutdown) {
00323
00324
PoShutdownBugCheck(
00325
FALSE,
00326 FATAL_UNHANDLED_HARD_ERROR,
00327 (ULONG)ErrorStatus,
00328 (ULONG_PTR)&(ParameterVector[0]),
00329 (ULONG_PTR)OemCaption,
00330 (ULONG_PTR)OemMessage
00331 );
00332
00333 }
00334
else {
00335
00336
KeBugCheckEx(
00337 FATAL_UNHANDLED_HARD_ERROR,
00338 (ULONG)ErrorStatus,
00339 (ULONG_PTR)&(ParameterVector[0]),
00340 (ULONG_PTR)OemCaption,
00341 (ULONG_PTR)OemMessage
00342 );
00343
00344 }
00345
00346 }
00347
00348
NTSTATUS
00349 ExpRaiseHardError(
00350 IN NTSTATUS ErrorStatus,
00351 IN ULONG NumberOfParameters,
00352 IN ULONG UnicodeStringParameterMask,
00353 IN PULONG_PTR Parameters,
00354 IN ULONG ValidResponseOptions,
00355 OUT PULONG Response
00356 )
00357 {
00358
00359
PEPROCESS Process;
00360 ULONG_PTR MessageBuffer[PORT_MAXIMUM_MESSAGE_LENGTH/
sizeof(ULONG_PTR)];
00361 PHARDERROR_MSG m;
00362
NTSTATUS Status;
00363 HANDLE ErrorPort;
00364
KPROCESSOR_MODE PreviousMode;
00365
00366
PAGED_CODE();
00367
00368 m = (PHARDERROR_MSG)&MessageBuffer[0];
00369 PreviousMode = KeGetPreviousMode();
00370
00371
if (ValidResponseOptions == OptionShutdownSystem) {
00372
00373
00374
00375
00376
00377
00378
if (!
SeSinglePrivilegeCheck(
SeShutdownPrivilege, PreviousMode )) {
00379
return STATUS_PRIVILEGE_NOT_HELD;
00380 }
00381
00382
ExReadyForErrors =
FALSE;
00383 }
00384
00385 Process =
PsGetCurrentProcess();
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
if ( !(
PsGetCurrentThread()->HardErrorsAreDisabled) ) {
00397
00398
if (
ExReadyForErrors ==
FALSE &&
NT_ERROR(ErrorStatus)){
00399
ExpSystemErrorHandler(
00400 ErrorStatus,
00401 NumberOfParameters,
00402 UnicodeStringParameterMask,
00403 Parameters,
00404 (BOOLEAN)((PreviousMode !=
KernelMode) ?
TRUE :
FALSE)
00405 );
00406 }
00407 }
00408
00409
00410
00411
00412
00413
00414
00415
00416
if ( Process->
ExceptionPort ) {
00417
if ( Process->
DefaultHardErrorProcessing & 1 ) {
00418 ErrorPort = Process->
ExceptionPort;
00419 }
00420
else {
00421
00422
00423
00424
00425
00426
if ( ErrorStatus & HARDERROR_OVERRIDE_ERRORMODE ) {
00427 ErrorPort = Process->
ExceptionPort;
00428 }
00429
else {
00430 ErrorPort =
NULL;
00431 }
00432 }
00433 }
00434
else {
00435
if ( Process->
DefaultHardErrorProcessing & 1 ) {
00436 ErrorPort =
ExpDefaultErrorPort;
00437 }
00438
else {
00439
00440
00441
00442
00443
00444
00445
if ( ErrorStatus & HARDERROR_OVERRIDE_ERRORMODE ) {
00446 ErrorPort =
ExpDefaultErrorPort;
00447 }
00448
else {
00449 ErrorPort =
NULL;
00450 }
00451 ErrorPort =
NULL;
00452 }
00453 }
00454
00455
if (
PsGetCurrentThread()->HardErrorsAreDisabled ) {
00456 ErrorPort =
NULL;
00457 }
00458
00459
if ( !
IS_SYSTEM_THREAD(
PsGetCurrentThread()) ) {
00460
try {
00461 PTEB Teb;
00462 Teb = (PTEB)
PsGetCurrentThread()->Tcb.Teb;
00463
if ( Teb->HardErrorsAreDisabled ) {
00464 ErrorPort =
NULL;
00465 }
00466 }
00467 except (
EXCEPTION_EXECUTE_HANDLER) {
00468 ;
00469 }
00470 }
00471
00472
if ( ErrorPort ) {
00473
if ( Process ==
ExpDefaultErrorPortProcess ) {
00474
if (
NT_ERROR(ErrorStatus) ) {
00475
ExpSystemErrorHandler(
00476 ErrorStatus,
00477 NumberOfParameters,
00478 UnicodeStringParameterMask,
00479 Parameters,
00480 (BOOLEAN)((PreviousMode !=
KernelMode) ?
TRUE :
FALSE)
00481 );
00482 }
00483 *Response = (ULONG)ResponseReturnToCaller;
00484
Status = STATUS_SUCCESS;
00485
return Status;
00486 }
00487 m->h.u1.Length =
HARDERROR_API_MSG_LENGTH;
00488 m->h.u2.ZeroInit = LPC_ERROR_EVENT;
00489 m->Status = ErrorStatus & ~HARDERROR_OVERRIDE_ERRORMODE;
00490 m->ValidResponseOptions = ValidResponseOptions;
00491 m->UnicodeStringParameterMask = UnicodeStringParameterMask;
00492 m->NumberOfParameters = NumberOfParameters;
00493
if ( Parameters ) {
00494 RtlMoveMemory(&m->Parameters,Parameters,
sizeof(ULONG_PTR)*NumberOfParameters);
00495 }
00496
KeQuerySystemTime(&m->ErrorTime);
00497
00498
Status =
LpcRequestWaitReplyPort(
00499 ErrorPort,
00500 (PPORT_MESSAGE) m,
00501 (PPORT_MESSAGE) m
00502 );
00503
if (
NT_SUCCESS(
Status) ) {
00504
switch ( m->Response ) {
00505
case ResponseReturnToCaller :
00506
case ResponseNotHandled :
00507
case ResponseAbort :
00508
case ResponseCancel :
00509
case ResponseIgnore :
00510
case ResponseNo :
00511
case ResponseOk :
00512
case ResponseRetry :
00513
case ResponseYes :
00514
case ResponseTryAgain :
00515
case ResponseContinue :
00516
break;
00517
default:
00518 m->Response = (ULONG)ResponseReturnToCaller;
00519
break;
00520 }
00521 *Response = m->Response;
00522 }
00523 }
00524
else {
00525 *Response = (ULONG)ResponseReturnToCaller;
00526
Status = STATUS_SUCCESS;
00527 }
00528
return Status;
00529 }
00530
00531
NTSTATUS
00532 NtRaiseHardError(
00533 IN NTSTATUS ErrorStatus,
00534 IN ULONG NumberOfParameters,
00535 IN ULONG UnicodeStringParameterMask,
00536 IN PULONG_PTR Parameters,
00537 IN ULONG ValidResponseOptions,
00538 OUT PULONG Response
00539 )
00540 {
00541
NTSTATUS Status;
00542 PULONG_PTR CapturedParameters;
00543
KPROCESSOR_MODE PreviousMode;
00544 ULONG LocalResponse;
00545 UNICODE_STRING CapturedString;
00546 ULONG Counter;
00547
00548
PAGED_CODE();
00549
00550
if ( NumberOfParameters > MAXIMUM_HARDERROR_PARAMETERS ) {
00551
return STATUS_INVALID_PARAMETER_2;
00552 }
00553
00554
if ( ARGUMENT_PRESENT(Parameters) && NumberOfParameters == 0 ) {
00555
return STATUS_INVALID_PARAMETER_2;
00556 }
00557
00558 PreviousMode = KeGetPreviousMode();
00559
if (PreviousMode !=
KernelMode) {
00560
switch ( ValidResponseOptions ) {
00561
case OptionAbortRetryIgnore :
00562
case OptionOk :
00563
case OptionOkCancel :
00564
case OptionRetryCancel :
00565
case OptionYesNo :
00566
case OptionYesNoCancel :
00567
case OptionShutdownSystem :
00568
case OptionOkNoWait :
00569
case OptionCancelTryContinue:
00570
break;
00571
default :
00572
return STATUS_INVALID_PARAMETER_4;
00573 }
00574
00575 CapturedParameters =
NULL;
00576
try {
00577
ProbeForWriteUlong(Response);
00578
00579
if ( ARGUMENT_PRESENT(Parameters) ) {
00580
ProbeForRead(
00581 Parameters,
00582
sizeof(ULONG_PTR)*NumberOfParameters,
00583
sizeof(ULONG_PTR)
00584 );
00585 CapturedParameters =
ExAllocatePoolWithTag(
PagedPool,
sizeof(ULONG_PTR)*NumberOfParameters, ' rrE');
00586
if ( !CapturedParameters ) {
00587
return STATUS_NO_MEMORY;
00588 }
00589 RtlMoveMemory(CapturedParameters,Parameters,
sizeof(ULONG_PTR)*NumberOfParameters);
00590
00591
00592
00593
00594
00595
if ( UnicodeStringParameterMask ) {
00596
for(Counter=0;Counter < NumberOfParameters;Counter++){
00597
00598
00599
00600
00601
00602
00603
if ( UnicodeStringParameterMask & (1<<Counter) ) {
00604
ProbeForRead(
00605 (PVOID)CapturedParameters[Counter],
00606
sizeof(UNICODE_STRING),
00607
sizeof(ULONG_PTR)
00608 );
00609 RtlMoveMemory(
00610 &CapturedString,
00611 (PVOID)CapturedParameters[Counter],
00612
sizeof(UNICODE_STRING)
00613 );
00614
00615
00616
00617
00618
00619
ProbeForRead(
00620 CapturedString.Buffer,
00621 CapturedString.MaximumLength,
00622
sizeof(UCHAR)
00623 );
00624
00625 }
00626 }
00627 }
00628 }
00629
else {
00630 CapturedParameters =
NULL;
00631 }
00632 }
00633 except(
EXCEPTION_EXECUTE_HANDLER) {
00634
if ( CapturedParameters ) {
00635
ExFreePool(CapturedParameters);
00636 }
00637
return GetExceptionCode();
00638 }
00639
00640
if (ErrorStatus == STATUS_SYSTEM_IMAGE_BAD_SIGNATURE &&
KdDebuggerEnabled) {
00641
if (NumberOfParameters && CapturedParameters) {
00642
DbgPrint(
"****************************************************************\n");
00643
DbgPrint(
"* The system detected a bad signature on file %wZ\n",(PUNICODE_STRING)CapturedParameters[0]);
00644
DbgPrint(
"****************************************************************\n");
00645 }
00646
if (CapturedParameters) {
00647
ExFreePool(CapturedParameters);
00648 }
00649
return STATUS_SUCCESS;
00650 }
00651
00652
00653
00654
00655
00656
00657
00658
00659
Status =
ExpRaiseHardError(
00660 ErrorStatus,
00661 NumberOfParameters,
00662 UnicodeStringParameterMask,
00663 CapturedParameters,
00664 ValidResponseOptions,
00665 &LocalResponse
00666 );
00667 }
00668
else {
00669 CapturedParameters = Parameters;
00670
00671
Status =
ExRaiseHardError(
00672 ErrorStatus,
00673 NumberOfParameters,
00674 UnicodeStringParameterMask,
00675 CapturedParameters,
00676 ValidResponseOptions,
00677 &LocalResponse
00678 );
00679 }
00680
00681
if (PreviousMode !=
KernelMode) {
00682
if ( CapturedParameters ) {
00683
ExFreePool(CapturedParameters);
00684 }
00685
try {
00686 *Response = LocalResponse;
00687 }
00688 except (
EXCEPTION_EXECUTE_HANDLER) {
00689
return Status;
00690 }
00691 }
00692
else {
00693 *Response = LocalResponse;
00694 }
00695
00696
return Status;
00697 }
00698
00699
NTSTATUS
00700 ExRaiseHardError(
00701 IN NTSTATUS ErrorStatus,
00702 IN ULONG NumberOfParameters,
00703 IN ULONG UnicodeStringParameterMask,
00704 IN PULONG_PTR Parameters,
00705 IN ULONG ValidResponseOptions,
00706 OUT PULONG Response
00707 )
00708 {
00709
NTSTATUS Status;
00710 PULONG_PTR ParameterBlock;
00711 PULONG_PTR UserModeParameterBase;
00712 PUNICODE_STRING UserModeStringsBase;
00713 PUCHAR UserModeStringDataBase;
00714 UNICODE_STRING CapturedStrings[MAXIMUM_HARDERROR_PARAMETERS];
00715 ULONG LocalResponse;
00716 ULONG Counter;
00717 SIZE_T UserModeSize;
00718
00719
PAGED_CODE();
00720
00721
00722
00723
00724
00725
00726
if (
ExpTooLateForErrors ) {
00727
00728 *Response = ResponseNotHandled;
00729
00730
return STATUS_SUCCESS;
00731 }
00732
00733
00734
00735
00736
00737
00738
00739
if ( ARGUMENT_PRESENT(Parameters) ) {
00740
if ( UnicodeStringParameterMask ) {
00741
00742
00743
00744
00745
00746
00747 UserModeSize = (
sizeof(ULONG_PTR)+
sizeof(UNICODE_STRING))*MAXIMUM_HARDERROR_PARAMETERS;
00748 UserModeSize +=
sizeof(UNICODE_STRING);
00749
00750
for(Counter=0;Counter < NumberOfParameters;Counter++){
00751
00752
00753
00754
00755
00756
00757
if ( UnicodeStringParameterMask & 1<<Counter ) {
00758
00759 RtlMoveMemory(
00760 &CapturedStrings[Counter],
00761 (PVOID)Parameters[Counter],
00762
sizeof(UNICODE_STRING)
00763 );
00764
00765 UserModeSize += CapturedStrings[Counter].MaximumLength;
00766
00767 }
00768 }
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778 ParameterBlock =
NULL;
00779
Status = ZwAllocateVirtualMemory(
00780 NtCurrentProcess(),
00781 (PVOID *)&ParameterBlock,
00782 0,
00783 &UserModeSize,
00784 MEM_COMMIT,
00785 PAGE_READWRITE
00786 );
00787
00788
if (!
NT_SUCCESS(
Status )) {
00789
return(
Status );
00790 }
00791
00792 UserModeParameterBase = ParameterBlock;
00793 UserModeStringsBase = (PUNICODE_STRING)((PUCHAR)ParameterBlock +
sizeof(ULONG)*MAXIMUM_HARDERROR_PARAMETERS);
00794 UserModeStringDataBase = (PUCHAR)UserModeStringsBase +
sizeof(UNICODE_STRING)*MAXIMUM_HARDERROR_PARAMETERS;
00795
00796
for(Counter=0;Counter < NumberOfParameters;Counter++){
00797
00798
00799
00800
00801
00802
00803
if ( UnicodeStringParameterMask & 1<<Counter ) {
00804
00805
00806
00807
00808
00809
00810 UserModeParameterBase[Counter] = (ULONG_PTR)&UserModeStringsBase[Counter];
00811
00812
00813
00814
00815
00816 RtlMoveMemory(
00817 UserModeStringDataBase,
00818 CapturedStrings[Counter].
Buffer,
00819 CapturedStrings[Counter].MaximumLength
00820 );
00821
00822 CapturedStrings[Counter].Buffer = (PWSTR)UserModeStringDataBase;
00823
00824
00825
00826
00827
00828 RtlMoveMemory(
00829 &UserModeStringsBase[Counter],
00830 &CapturedStrings[Counter],
00831
sizeof(UNICODE_STRING)
00832 );
00833
00834
00835
00836
00837
00838 UserModeStringDataBase += CapturedStrings[Counter].MaximumLength;
00839
00840 }
00841
else {
00842 UserModeParameterBase[Counter] = Parameters[Counter];
00843 }
00844 }
00845 }
00846
else {
00847 ParameterBlock = Parameters;
00848 }
00849 }
00850
else {
00851 ParameterBlock =
NULL;
00852 }
00853
00854
00855
00856
00857
00858
Status =
ExpRaiseHardError(
00859 ErrorStatus,
00860 NumberOfParameters,
00861 UnicodeStringParameterMask,
00862 ParameterBlock,
00863 ValidResponseOptions,
00864 &LocalResponse
00865 );
00866
00867
00868
00869
00870
00871
if ( ParameterBlock && ParameterBlock != Parameters ) {
00872 UserModeSize = 0;
00873 ZwFreeVirtualMemory(
00874 NtCurrentProcess(),
00875 (PVOID *)&ParameterBlock,
00876 &UserModeSize,
00877 MEM_RELEASE
00878 );
00879 }
00880 *Response = LocalResponse;
00881
00882
return Status;
00883 }
00884
00885
NTSTATUS
00886 NtSetDefaultHardErrorPort(
00887 IN HANDLE DefaultHardErrorPort
00888 )
00889 {
00890
NTSTATUS Status;
00891
00892
PAGED_CODE();
00893
00894
if (!
SeSinglePrivilegeCheck(
SeTcbPrivilege, KeGetPreviousMode() )) {
00895
return STATUS_PRIVILEGE_NOT_HELD;
00896 }
00897
00898
if (
ExReadyForErrors ) {
00899
return STATUS_UNSUCCESSFUL;
00900 }
00901
00902
00903
00904
00905
00906
Status =
ObReferenceObjectByHandle (
00907 DefaultHardErrorPort,
00908 0,
00909
LpcPortObjectType,
00910 KeGetPreviousMode(),
00911 (PVOID *)&
ExpDefaultErrorPort,
00912
NULL
00913 );
00914
if ( !
NT_SUCCESS(
Status) ) {
00915
return Status;
00916 }
00917
00918
ExReadyForErrors =
TRUE;
00919
ExpDefaultErrorPortProcess =
PsGetCurrentProcess();
00920
00921
return STATUS_SUCCESS;
00922 }
00923
00924
VOID
00925 __cdecl
00926 _purecall()
00927 {
00928
ASSERTMSG(
"_purecall() was called",
FALSE);
00929
ExRaiseStatus(STATUS_NOT_IMPLEMENTED);
00930 }