xref: /reactos/ntoskrnl/ex/harderr.c (revision aad80191) 
1 /*
2  * PROJECT:         ReactOS Kernel
3  * LICENSE:         GPL - See COPYING in the top level directory
4  * FILE:            ntoskrnl/ex/harderr.c
5  * PURPOSE:         Error Functions and Status/Exception Dispatching/Raising
6  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
7  */
8 
9 /* INCLUDES *****************************************************************/
10 
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14 
15 #define TAG_ERR ' rrE'
16 
17 /* GLOBALS ******************************************************************/
18 
19 BOOLEAN ExReadyForErrors = FALSE;
20 PVOID ExpDefaultErrorPort = NULL;
21 PEPROCESS ExpDefaultErrorPortProcess = NULL;
22 
23 /* FUNCTIONS ****************************************************************/
24 
25 /*++
26 * @name ExpSystemErrorHandler
27 *
28 * For now it's a stub
29 *
30 * @param ErrorStatus
31 *        FILLME
32 *
33 * @param NumberOfParameters
34 *        FILLME
35 *
36 * @param UnicodeStringParameterMask
37 *        FILLME
38 *
39 * @param Parameters
40 *        FILLME
41 *
42 * @param ValidResponseOptions
43 *        FILLME
44 *
45 * @param Response
46 *        FILLME
47 *
48 * @return None
49 *
50 * @remarks None
51 *
52 *--*/
53 NTSTATUS
54 NTAPI
55 ExpSystemErrorHandler(IN NTSTATUS ErrorStatus,
56                       IN ULONG NumberOfParameters,
57                       IN ULONG UnicodeStringParameterMask,
58                       IN PULONG_PTR Parameters,
59                       IN BOOLEAN Shutdown)
60 {
61     ULONG_PTR BugCheckParameters[MAXIMUM_HARDERROR_PARAMETERS] = {0, 0, 0, 0};
62     ULONG i;
63 
64     /* Sanity check */
65     ASSERT(NumberOfParameters <= MAXIMUM_HARDERROR_PARAMETERS);
66 
67     /*
68      * KeBugCheck expects MAXIMUM_HARDERROR_PARAMETERS parameters,
69      * but we might get called with less, so use a local buffer here.
70      */
71     for (i = 0; i < NumberOfParameters; i++)
72     {
73         /* Copy them over */
74         BugCheckParameters[i] = Parameters[i];
75     }
76 
77     /* FIXME: STUB */
78     KeBugCheckEx(FATAL_UNHANDLED_HARD_ERROR,
79                  ErrorStatus,
80                  (ULONG_PTR)BugCheckParameters,
81                  0,
82                  0);
83     return STATUS_SUCCESS;
84 }
85 
86 /*++
87  * @name ExpRaiseHardError
88  * @implemented
89  *
90  * See ExRaiseHardError and NtRaiseHardError, same parameters.
91  *
92  * This function performs the central work for both ExRaiseHardError
93  * and NtRaiseHardError. ExRaiseHardError is the service for kernel-mode
94  * that copies the parameters to user-mode, and NtRaiseHardError is the
95  * service for both kernel-mode and user-mode that performs parameters
96  * validation and capture if necessary.
97  *
98  *--*/
99 NTSTATUS
100 NTAPI
101 ExpRaiseHardError(IN NTSTATUS ErrorStatus,
102                   IN ULONG NumberOfParameters,
103                   IN ULONG UnicodeStringParameterMask,
104                   IN PULONG_PTR Parameters,
105                   IN ULONG ValidResponseOptions,
106                   OUT PULONG Response)
107 {
108     NTSTATUS Status;
109     PEPROCESS Process = PsGetCurrentProcess();
110     PETHREAD Thread = PsGetCurrentThread();
111     UCHAR Buffer[PORT_MAXIMUM_MESSAGE_LENGTH];
112     PHARDERROR_MSG Message = (PHARDERROR_MSG)Buffer;
113     HANDLE PortHandle;
114     KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
115 
116     PAGED_CODE();
117 
118     /* Check if this error will shutdown the system */
119     if (ValidResponseOptions == OptionShutdownSystem)
120     {
121         /*
122          * Check if we have the privileges.
123          *
124          * NOTE: In addition to the Shutdown privilege we also check whether
125          * the caller has the Tcb privilege. The purpose is to allow only
126          * SYSTEM processes to "shutdown" the system on hard errors (BSOD)
127          * while forbidding regular processes to do so. This behaviour differs
128          * from Windows, where any user-mode process, as soon as it has the
129          * Shutdown privilege, can trigger a hard-error BSOD.
130          */
131         if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode) ||
132             !SeSinglePrivilegeCheck(SeShutdownPrivilege, PreviousMode))
133         {
134             /* No rights */
135             *Response = ResponseNotHandled;
136             return STATUS_PRIVILEGE_NOT_HELD;
137         }
138 
139         /* Don't handle any new hard errors */
140         ExReadyForErrors = FALSE;
141     }
142 
143     /* Check if hard errors are not disabled */
144     if (!Thread->HardErrorsAreDisabled)
145     {
146         /* Check if we can't do errors anymore, and this is serious */
147         if (!ExReadyForErrors && NT_ERROR(ErrorStatus))
148         {
149             /* Use the system handler */
150             ExpSystemErrorHandler(ErrorStatus,
151                                   NumberOfParameters,
152                                   UnicodeStringParameterMask,
153                                   Parameters,
154                                   (PreviousMode != KernelMode) ? TRUE : FALSE);
155         }
156     }
157 
158     /*
159      * Enable hard error processing if it is enabled for the process
160      * or if the exception status forces it.
161      */
162     if ((Process->DefaultHardErrorProcessing & SEM_FAILCRITICALERRORS) ||
163         (ErrorStatus & HARDERROR_OVERRIDE_ERRORMODE))
164     {
165         /* Check if we have an exception port */
166         if (Process->ExceptionPort)
167         {
168             /* Use the port */
169             PortHandle = Process->ExceptionPort;
170         }
171         else
172         {
173             /* Use our default system port */
174             PortHandle = ExpDefaultErrorPort;
175         }
176     }
177     else
178     {
179         /* Don't process the error */
180         PortHandle = NULL;
181     }
182 
183     /* If hard errors are disabled, do nothing */
184     if (Thread->HardErrorsAreDisabled) PortHandle = NULL;
185 
186     /*
187      * If this is not the system thread, check whether hard errors are
188      * disabled for this thread on user-mode side, and if so, do nothing.
189      */
190     if (!Thread->SystemThread && (PortHandle != NULL))
191     {
192         /* Check if we have a TEB */
193         PTEB Teb = PsGetCurrentThread()->Tcb.Teb;
194         if (Teb)
195         {
196             _SEH2_TRY
197             {
198                 if (Teb->HardErrorMode & RTL_SEM_FAILCRITICALERRORS)
199                 {
200                     PortHandle = NULL;
201                 }
202             }
203             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
204             {
205                 NOTHING;
206             }
207             _SEH2_END;
208         }
209     }
210 
211     /* Now check if we have a port */
212     if (PortHandle == NULL)
213     {
214         /* Just return to caller */
215         *Response = ResponseReturnToCaller;
216         return STATUS_SUCCESS;
217     }
218 
219     /* Check if this is the default process */
220     if (Process == ExpDefaultErrorPortProcess)
221     {
222         /* We can't handle the error, check if this is critical */
223         if (NT_ERROR(ErrorStatus))
224         {
225             /* It is, invoke the system handler */
226             ExpSystemErrorHandler(ErrorStatus,
227                                   NumberOfParameters,
228                                   UnicodeStringParameterMask,
229                                   Parameters,
230                                   (PreviousMode != KernelMode) ? TRUE : FALSE);
231 
232             /* If we survived, return to caller */
233             *Response = ResponseReturnToCaller;
234             return STATUS_SUCCESS;
235         }
236     }
237 
238     /* Setup the LPC Message */
239     Message->h.u1.Length = (sizeof(HARDERROR_MSG) << 16) |
240                            (sizeof(HARDERROR_MSG) - sizeof(PORT_MESSAGE));
241     Message->h.u2.ZeroInit = 0;
242     Message->h.u2.s2.Type = LPC_ERROR_EVENT;
243     Message->Status = ErrorStatus & ~HARDERROR_OVERRIDE_ERRORMODE;
244     Message->ValidResponseOptions = ValidResponseOptions;
245     Message->UnicodeStringParameterMask = UnicodeStringParameterMask;
246     Message->NumberOfParameters = NumberOfParameters;
247     KeQuerySystemTime(&Message->ErrorTime);
248 
249     /* Copy the parameters */
250     if (Parameters)
251     {
252         RtlMoveMemory(&Message->Parameters,
253                       Parameters,
254                       sizeof(ULONG_PTR) * NumberOfParameters);
255     }
256 
257     /* Send the LPC Message */
258     Status = LpcRequestWaitReplyPort(PortHandle,
259                                      (PPORT_MESSAGE)Message,
260                                      (PPORT_MESSAGE)Message);
261     if (NT_SUCCESS(Status))
262     {
263         /* Check what kind of response we got */
264         if ((Message->Response != ResponseReturnToCaller) &&
265             (Message->Response != ResponseNotHandled) &&
266             (Message->Response != ResponseAbort) &&
267             (Message->Response != ResponseCancel) &&
268             (Message->Response != ResponseIgnore) &&
269             (Message->Response != ResponseNo) &&
270             (Message->Response != ResponseOk) &&
271             (Message->Response != ResponseRetry) &&
272             (Message->Response != ResponseYes) &&
273             (Message->Response != ResponseTryAgain) &&
274             (Message->Response != ResponseContinue))
275         {
276             /* Reset to a default one */
277             Message->Response = ResponseReturnToCaller;
278         }
279 
280         /* Set the response */
281         *Response = Message->Response;
282     }
283     else
284     {
285         /* Set the response */
286         *Response = ResponseReturnToCaller;
287     }
288 
289     /* Return status */
290     return Status;
291 }
292 
293 /*++
294  * @name ExRaiseAccessViolation
295  * @implemented
296  *
297  * The ExRaiseAccessViolation routine can be used with structured exception
298  * handling to throw a driver-determined exception for a memory access
299  * violation that occurs when a driver processes I/O requests.
300  * See: http://msdn.microsoft.com/library/en-us/Kernel_r/hh/Kernel_r/k102_71b4c053-599c-4a6d-8a59-08aae6bdc534.xml.asp?frame=true
301  *      http://www.osronline.com/ddkx/kmarch/k102_814i.htm
302  *
303  * @return None
304  *
305  * @remarks None
306  *
307  *--*/
308 VOID
309 NTAPI
310 ExRaiseAccessViolation(VOID)
311 {
312     /* Raise the Right Status */
313     RtlRaiseStatus(STATUS_ACCESS_VIOLATION);
314 }
315 
316 /*++
317  * @name ExRaiseDatatypeMisalignment
318  * @implemented
319  *
320  * ExRaiseDatatypeMisalignment raises an exception with the exception
321  * code set to STATUS_DATATYPE_MISALIGNMENT
322  * See: MSDN / DDK
323  *      http://www.osronline.com/ddkx/kmarch/k102_814i.htm
324  *
325  * @return None
326  *
327  * @remarks None
328  *
329  *--*/
330 VOID
331 NTAPI
332 ExRaiseDatatypeMisalignment(VOID)
333 {
334     /* Raise the Right Status */
335     RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
336 }
337 
338 /*++
339  * @name ExSystemExceptionFilter
340  * @implemented
341  *
342  * TODO: Add description
343  *
344  * @return FILLME
345  *
346  * @remarks None
347  *
348  *--*/
349 LONG
350 NTAPI
351 ExSystemExceptionFilter(VOID)
352 {
353     return KeGetPreviousMode() != KernelMode ?
354            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
355 }
356 
357 /*++
358  * @name ExRaiseHardError
359  * @implemented
360  *
361  * See NtRaiseHardError and ExpRaiseHardError.
362  *
363  * @param ErrorStatus
364  *        Error Code
365  *
366  * @param NumberOfParameters
367  *        Number of optional parameters in Parameters array
368  *
369  * @param UnicodeStringParameterMask
370  *        Optional string parameter (can be only one per error code)
371  *
372  * @param Parameters
373  *        Array of ULONG parameters for use in error message string
374  *
375  * @param ValidResponseOptions
376  *        See HARDERROR_RESPONSE_OPTION for possible values description
377  *
378  * @param Response
379  *        Pointer to HARDERROR_RESPONSE enumeration
380  *
381  * @return Status
382  *
383  *--*/
384 NTSTATUS
385 NTAPI
386 ExRaiseHardError(IN NTSTATUS ErrorStatus,
387                  IN ULONG NumberOfParameters,
388                  IN ULONG UnicodeStringParameterMask,
389                  IN PULONG_PTR Parameters,
390                  IN ULONG ValidResponseOptions,
391                  OUT PULONG Response)
392 {
393     NTSTATUS Status;
394     SIZE_T Size;
395     UNICODE_STRING CapturedParams[MAXIMUM_HARDERROR_PARAMETERS];
396     ULONG i;
397     PVOID UserData = NULL;
398     PHARDERROR_USER_PARAMETERS UserParams;
399     PWSTR BufferBase;
400     ULONG SafeResponse = ResponseNotHandled;
401 
402     PAGED_CODE();
403 
404     /* Check if we have parameters */
405     if (Parameters)
406     {
407         /* Check if we have strings */
408         if (UnicodeStringParameterMask)
409         {
410             /* Calculate the required size */
411             Size = FIELD_OFFSET(HARDERROR_USER_PARAMETERS, Buffer[0]);
412 
413             /* Loop each parameter */
414             for (i = 0; i < NumberOfParameters; i++)
415             {
416                 /* Check if it's part of the mask */
417                 if (UnicodeStringParameterMask & (1 << i))
418                 {
419                     /* Copy it */
420                     RtlMoveMemory(&CapturedParams[i],
421                                   (PVOID)Parameters[i],
422                                   sizeof(UNICODE_STRING));
423 
424                     /* Increase the size */
425                     Size += CapturedParams[i].MaximumLength;
426                 }
427             }
428 
429             /* Allocate the user data region */
430             Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
431                                              &UserData,
432                                              0,
433                                              &Size,
434                                              MEM_COMMIT,
435                                              PAGE_READWRITE);
436             if (!NT_SUCCESS(Status))
437             {
438                 /* Return failure */
439                 *Response = ResponseNotHandled;
440                 return Status;
441             }
442 
443             /* Set the pointers to our data */
444             UserParams = UserData;
445             BufferBase = UserParams->Buffer;
446 
447             /* Enter SEH block as we are writing to user-mode space */
448             _SEH2_TRY
449             {
450                 /* Loop parameters again */
451                 for (i = 0; i < NumberOfParameters; i++)
452                 {
453                     /* Check if we are in the mask */
454                     if (UnicodeStringParameterMask & (1 << i))
455                     {
456                         /* Update the base */
457                         UserParams->Parameters[i] = (ULONG_PTR)&UserParams->Strings[i];
458 
459                         /* Copy the string buffer */
460                         RtlMoveMemory(BufferBase,
461                                       CapturedParams[i].Buffer,
462                                       CapturedParams[i].MaximumLength);
463 
464                         /* Set buffer */
465                         CapturedParams[i].Buffer = BufferBase;
466 
467                         /* Copy the string structure */
468                         UserParams->Strings[i] = CapturedParams[i];
469 
470                         /* Update the pointer */
471                         BufferBase += CapturedParams[i].MaximumLength;
472                     }
473                     else
474                     {
475                         /* No need to copy any strings */
476                         UserParams->Parameters[i] = Parameters[i];
477                     }
478                 }
479             }
480             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
481             {
482                 /* Return the exception code */
483                 Status = _SEH2_GetExceptionCode();
484                 DPRINT1("ExRaiseHardError - Exception when writing data to user-mode, Status 0x%08lx\n", Status);
485             }
486             _SEH2_END;
487         }
488         else
489         {
490             /* Just keep the data as is */
491             UserData = Parameters;
492         }
493     }
494 
495     /* Now call the worker function */
496     Status = ExpRaiseHardError(ErrorStatus,
497                                NumberOfParameters,
498                                UnicodeStringParameterMask,
499                                UserData,
500                                ValidResponseOptions,
501                                &SafeResponse);
502 
503     /* Check if we had done user-mode allocation */
504     if ((UserData) && (UserData != Parameters))
505     {
506         /* We did! Delete it */
507         Size = 0;
508         ZwFreeVirtualMemory(NtCurrentProcess(),
509                             &UserData,
510                             &Size,
511                             MEM_RELEASE);
512     }
513 
514     /* Return status and the response */
515     *Response = SafeResponse;
516     return Status;
517 }
518 
519 /*++
520  * @name NtRaiseHardError
521  * @implemented
522  *
523  * This function sends HARDERROR_MSG LPC message to a hard-error listener,
524  * typically CSRSS.EXE. See NtSetDefaultHardErrorPort for more information.
525  * See also: http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Error/NtRaiseHardError.html
526  *
527  * @param ErrorStatus
528  *        Error Code
529  *
530  * @param NumberOfParameters
531  *        Number of optional parameters in Parameters array
532  *
533  * @param UnicodeStringParameterMask
534  *        Optional string parameter (can be only one per error code)
535  *
536  * @param Parameters
537  *        Array of ULONG_PTR parameters for use in error message string
538  *
539  * @param ValidResponseOptions
540  *        See HARDERROR_RESPONSE_OPTION for possible values description
541  *
542  * @param Response
543  *        Pointer to HARDERROR_RESPONSE enumeration
544  *
545  * @return Status
546  *
547  * @remarks NtRaiseHardError constitutes an easy way to display messages
548  *          in GUI without loading any Win32 API libraries.
549  *
550  *--*/
551 NTSTATUS
552 NTAPI
553 NtRaiseHardError(IN NTSTATUS ErrorStatus,
554                  IN ULONG NumberOfParameters,
555                  IN ULONG UnicodeStringParameterMask,
556                  IN PULONG_PTR Parameters,
557                  IN ULONG ValidResponseOptions,
558                  OUT PULONG Response)
559 {
560     NTSTATUS Status = STATUS_SUCCESS;
561     PULONG_PTR SafeParams = NULL;
562     ULONG SafeResponse = ResponseNotHandled;
563     UNICODE_STRING SafeString;
564     ULONG i;
565     ULONG ParamSize = 0;
566     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
567 
568     PAGED_CODE();
569 
570     /* Validate parameter count */
571     if (NumberOfParameters > MAXIMUM_HARDERROR_PARAMETERS)
572     {
573         /* Fail */
574         return STATUS_INVALID_PARAMETER_2;
575     }
576 
577     /* Make sure we have some at least */
578     if ((Parameters != NULL) && (NumberOfParameters == 0))
579     {
580         /* Fail */
581         return STATUS_INVALID_PARAMETER_2;
582     }
583 
584     /* Check if we were called from user-mode */
585     if (PreviousMode != KernelMode)
586     {
587         /* First validate the responses */
588         switch (ValidResponseOptions)
589         {
590             /* Check all valid cases */
591             case OptionAbortRetryIgnore:
592             case OptionOk:
593             case OptionOkCancel:
594             case OptionRetryCancel:
595             case OptionYesNo:
596             case OptionYesNoCancel:
597             case OptionShutdownSystem:
598             case OptionOkNoWait:
599             case OptionCancelTryContinue:
600                 break;
601 
602             /* Anything else is invalid */
603             default:
604                 return STATUS_INVALID_PARAMETER_4;
605         }
606 
607         /* Check if we have parameters */
608         if (Parameters)
609         {
610             /* Calculate size of the parameters */
611             ParamSize = sizeof(ULONG_PTR) * NumberOfParameters;
612 
613             /* Allocate a safe buffer */
614             SafeParams = ExAllocatePoolWithTag(PagedPool, ParamSize, TAG_ERR);
615             if (!SafeParams)
616             {
617                 return STATUS_INSUFFICIENT_RESOURCES;
618             }
619         }
620 
621         /* Enter SEH Block */
622         _SEH2_TRY
623         {
624             /* Validate the response pointer */
625             ProbeForWriteUlong(Response);
626 
627             /* Check if we have parameters */
628             if (Parameters)
629             {
630                 /* Validate the parameter pointers */
631                 ProbeForRead(Parameters, ParamSize, sizeof(ULONG_PTR));
632 
633                 /* Copy them */
634                 RtlCopyMemory(SafeParams, Parameters, ParamSize);
635 
636                 /* Now check if there's strings in it */
637                 if (UnicodeStringParameterMask)
638                 {
639                     /* Loop every string */
640                     for (i = 0; i < NumberOfParameters; i++)
641                     {
642                         /* Check if this parameter is a string */
643                         if (UnicodeStringParameterMask & (1 << i))
644                         {
645                             /* Probe the structure */
646                             ProbeForRead((PVOID)SafeParams[i],
647                                          sizeof(UNICODE_STRING),
648                                          sizeof(ULONG_PTR));
649 
650                             /* Capture it */
651                             RtlCopyMemory(&SafeString,
652                                           (PVOID)SafeParams[i],
653                                           sizeof(UNICODE_STRING));
654 
655                             /* Probe the buffer */
656                             ProbeForRead(SafeString.Buffer,
657                                          SafeString.MaximumLength,
658                                          sizeof(UCHAR));
659                         }
660                     }
661                 }
662             }
663         }
664         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
665         {
666             /* Free captured buffer */
667             if (SafeParams) ExFreePoolWithTag(SafeParams, TAG_ERR);
668 
669             /* Return the exception code */
670             _SEH2_YIELD(return _SEH2_GetExceptionCode());
671         }
672         _SEH2_END;
673 
674         /* Call the system function directly, because we probed */
675         Status = ExpRaiseHardError(ErrorStatus,
676                                    NumberOfParameters,
677                                    UnicodeStringParameterMask,
678                                    SafeParams,
679                                    ValidResponseOptions,
680                                    &SafeResponse);
681 
682         /* Free captured buffer */
683         if (SafeParams) ExFreePoolWithTag(SafeParams, TAG_ERR);
684 
685         /* Enter SEH Block to return the response */
686         _SEH2_TRY
687         {
688             /* Return the response */
689             *Response = SafeResponse;
690         }
691         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
692         {
693             /* Get the exception code */
694             Status = _SEH2_GetExceptionCode();
695         }
696         _SEH2_END;
697     }
698     else
699     {
700         /* Reuse variable */
701         SafeParams = Parameters;
702 
703         /*
704          * Call the Executive Function. It will probe
705          * and copy pointers to user-mode.
706          */
707         Status = ExRaiseHardError(ErrorStatus,
708                                   NumberOfParameters,
709                                   UnicodeStringParameterMask,
710                                   SafeParams,
711                                   ValidResponseOptions,
712                                   &SafeResponse);
713 
714         /* Return the response */
715         *Response = SafeResponse;
716     }
717 
718     /* Return status */
719     return Status;
720 }
721 
722 /*++
723  * @name NtSetDefaultHardErrorPort
724  * @implemented
725  *
726  * NtSetDefaultHardErrorPort is typically called only once. After the call,
727  * the kernel sets a BOOLEAN flag named ExReadyForErrors to TRUE, and all other
728  * attempts to change the default port fail with STATUS_UNSUCCESSFUL error code.
729  * See: http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Error/NtSetDefaultHardErrorPort.html
730  *      https://web.archive.org/web/20070716133753/http://www.windowsitlibrary.com/Content/356/08/2.html
731  *
732  * @param PortHandle
733  *        Handle to named port object
734  *
735  * @return Status
736  *
737  * @remarks Privileges: SE_TCB_PRIVILEGE
738  *
739  *--*/
740 NTSTATUS
741 NTAPI
742 NtSetDefaultHardErrorPort(IN HANDLE PortHandle)
743 {
744     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
745     NTSTATUS Status = STATUS_UNSUCCESSFUL;
746 
747     PAGED_CODE();
748 
749     /* Check if we have the privileges */
750     if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
751     {
752         DPRINT1("NtSetDefaultHardErrorPort: Caller requires "
753                 "the SeTcbPrivilege privilege!\n");
754         return STATUS_PRIVILEGE_NOT_HELD;
755     }
756 
757     /* Only called once during bootup, make sure we weren't called yet */
758     if (!ExReadyForErrors)
759     {
760         /* Reference the hard-error port */
761         Status = ObReferenceObjectByHandle(PortHandle,
762                                            0,
763                                            LpcPortObjectType,
764                                            PreviousMode,
765                                            (PVOID*)&ExpDefaultErrorPort,
766                                            NULL);
767         if (NT_SUCCESS(Status))
768         {
769             /* Keep also a reference to the process handling the hard errors */
770             ExpDefaultErrorPortProcess = PsGetCurrentProcess();
771             ObReferenceObject(ExpDefaultErrorPortProcess);
772             ExReadyForErrors = TRUE;
773             Status = STATUS_SUCCESS;
774         }
775     }
776 
777     /* Return status to caller */
778     return Status;
779 }
780 
781 VOID
782 __cdecl
783 _purecall(VOID)
784 {
785     /* Not supported in Kernel Mode */
786     RtlRaiseStatus(STATUS_NOT_IMPLEMENTED);
787 }
788 
789 /* EOF */
790