Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-28 10:04:49 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Move more stuff to /rtl

Browse source 
- Bring back Ki* callbacks into ntdll.

svn path=/trunk/; revision=17732
This commit is contained in:
Alex Ionescu 2005-09-08 02:29:30 +00:00
parent c39ccd6592
commit 7206207210
15 changed files with 1028 additions and 1108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
reactos/lib/ntdll/def/ntdll.def
View file

@ -317,7 +317,6 @@ RtlAreAnyAccessesGranted@8
RtlAreBitsClear@12
RtlAreBitsSet@12
RtlAssert@16
RtlBaseProcessStartRoutine DATA
;RtlCaptureStackBackTrace
RtlCharToInteger@12
RtlCheckRegistryKey@8

41
reactos/lib/ntdll/inc/ntdllp.h
View file

@ -27,50 +27,11 @@ typedef BOOL
(STDCALL *PDLLMAIN_FUNC)(HANDLE hInst,
ULONG ul_reason_for_call,
LPVOID lpReserved);
VOID
STDCALL
RtlpInitDeferedCriticalSection(
VOID
);
#if defined(KDBG) || defined(DBG)
VOID
LdrpLoadUserModuleSymbols(PLDR_DATA_TABLE_ENTRY LdrModule);
#endif
extern HANDLE WindowsApiPort;
NTSTATUS
STDCALL
RtlpWaitForCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection
);
VOID
STDCALL
RtlpUnWaitCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection
);
VOID
STDCALL
RtlpCreateCriticalSectionSem(
PRTL_CRITICAL_SECTION CriticalSection
);
VOID
STDCALL
RtlpInitDeferedCriticalSection(
VOID
);
VOID
STDCALL
RtlpFreeDebugInfo(
PRTL_CRITICAL_SECTION_DEBUG DebugInfo
);
PRTL_CRITICAL_SECTION_DEBUG
STDCALL
RtlpAllocateDebugInfo(
VOID
);
/* EOF */

1
reactos/lib/ntdll/ldr/startup.c
View file

@ -17,6 +17,7 @@
VOID RtlInitializeHeapManager (VOID);
VOID LdrpInitLoader(VOID);
VOID STDCALL RtlpInitDeferedCriticalSection(VOID);
/* GLOBALS *******************************************************************/

121
reactos/lib/ntdll/main/dispatch.c Normal file
View file

@ -0,0 +1,121 @@
/* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* PURPOSE: User-mode APC support
* FILE: lib/ntdll/main/dispatch.c
* PROGRAMER: David Welch <welch@cwcom.net>
*/
/* INCLUDES *****************************************************************/
#include <ntdll.h>
#define NDEBUG
#include <debug.h>
typedef NTSTATUS (STDCALL *KERNEL_CALLBACK_FUNCTION)(PVOID Argument,
ULONG ArgumentLength);
EXCEPTION_DISPOSITION
RtlpExecuteVectoredExceptionHandlers(IN PEXCEPTION_RECORD ExceptionRecord,
IN PCONTEXT Context);
ULONG
RtlpDispatchException(IN PEXCEPTION_RECORD ExceptionRecord,
IN PCONTEXT Context);
/* FUNCTIONS ****************************************************************/
/*
* @implemented
*/
VOID
STDCALL
KiUserApcDispatcher(PIO_APC_ROUTINE ApcRoutine,
PVOID ApcContext,
PIO_STATUS_BLOCK Iosb,
ULONG Reserved,
PCONTEXT Context)
{
/*
* Call the APC
*/
//DPRINT1("ITS ME\n");
ApcRoutine(ApcContext,
Iosb,
Reserved);
/*
* Switch back to the interrupted context
*/
//DPRINT1("switch back\n");
NtContinue(Context, 1);
}
/*
* @implemented
*/
VOID
STDCALL
KiUserExceptionDispatcher(PEXCEPTION_RECORD ExceptionRecord,
PCONTEXT Context)
{
EXCEPTION_RECORD NestedExceptionRecord;
NTSTATUS Status;
if(RtlpExecuteVectoredExceptionHandlers(ExceptionRecord,
Context) != ExceptionContinueExecution)
{
Status = NtContinue(Context, FALSE);
}
else
{
if(RtlpDispatchException(ExceptionRecord, Context) != ExceptionContinueExecution)
{
Status = NtContinue(Context, FALSE);
}
else
{
Status = NtRaiseException(ExceptionRecord, Context, FALSE);
}
}
NestedExceptionRecord.ExceptionCode = Status;
NestedExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
NestedExceptionRecord.ExceptionRecord = ExceptionRecord;
NestedExceptionRecord.NumberParameters = Status;
RtlRaiseException(&NestedExceptionRecord);
}
/*
* @implemented
*/
VOID
STDCALL
KiRaiseUserExceptionDispatcher(VOID)
{
EXCEPTION_RECORD ExceptionRecord;
ExceptionRecord.ExceptionCode = ((PTEB)NtCurrentTeb())->ExceptionCode;
ExceptionRecord.ExceptionFlags = 0;
ExceptionRecord.ExceptionRecord = NULL;
ExceptionRecord.NumberParameters = 0;
RtlRaiseException(&ExceptionRecord);
}
/*
* @implemented
*/
VOID
STDCALL
KiUserCallbackDispatcher(ULONG RoutineIndex,
PVOID Argument,
ULONG ArgumentLength)
{
PPEB Peb;
NTSTATUS Status;
KERNEL_CALLBACK_FUNCTION Callback;
Peb = NtCurrentPeb();
Callback = (KERNEL_CALLBACK_FUNCTION)Peb->KernelCallbackTable[RoutineIndex];
Status = Callback(Argument, ArgumentLength);
ZwCallbackReturn(NULL, 0, Status);
}

4
reactos/lib/ntdll/ntdll.xml
View file

@ -29,13 +29,11 @@
<file>utils.c</file>
</directory>
<directory name="main">
<file>dispatch.c</file>
<file>dllmain.c</file>
</directory>
<directory name="rtl">
<file>critical.c</file>
<file>exception.c</file>
<file>libsupp.c</file>
<file>path.c</file>
<file>version.c</file>
</directory>
<directory name="stdio">

32
reactos/lib/ntdll/rtl/libsupp.c
View file

@ -61,6 +61,38 @@ RtlGetNtGlobalFlags(VOID)
return pPeb->NtGlobalFlag;
}
NTSTATUS
STDCALL
RtlDeleteHeapLock(
PRTL_CRITICAL_SECTION CriticalSection)
{
return RtlDeleteCriticalSection(CriticalSection);
}
NTSTATUS
STDCALL
RtlEnterHeapLock(
PRTL_CRITICAL_SECTION CriticalSection)
{
return RtlEnterCriticalSection(CriticalSection);
}
NTSTATUS
STDCALL
RtlInitializeHeapLock(
PRTL_CRITICAL_SECTION CriticalSection)
{
return RtlInitializeCriticalSection(CriticalSection );
}
NTSTATUS
STDCALL
RtlLeaveHeapLock(
PRTL_CRITICAL_SECTION CriticalSection)
{
return RtlLeaveCriticalSection(CriticalSection );
}
PVOID
STDCALL
RtlpAllocateMemory(UINT Bytes,

37
reactos/lib/rtl/apc.c
View file

@ -1,37 +0,0 @@
/* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* PURPOSE: User-mode APC support
* FILE: lib/rtl/apc.c
* PROGRAMER: David Welch <welch@cwcom.net>
*/
/* INCLUDES *****************************************************************/
#include <rtl.h>
#define NDEBUG
#include <debug.h>
/* FUNCTIONS ****************************************************************/
VOID STDCALL
KiUserApcDispatcher(PIO_APC_ROUTINE ApcRoutine,
PVOID ApcContext,
PIO_STATUS_BLOCK Iosb,
ULONG Reserved,
PCONTEXT Context)
{
/*
* Call the APC
*/
//DPRINT1("ITS ME\n");
ApcRoutine(ApcContext,
Iosb,
Reserved);
/*
* Switch back to the interrupted context
*/
//DPRINT1("switch back\n");
NtContinue(Context, 1);
}

35
reactos/lib/rtl/callback.c
View file

@ -1,35 +0,0 @@
/* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* PURPOSE: User-mode callback support
* FILE: lib/rtl/callback.c
* PROGRAMER: David Welch <welch@cwcom.net>
*/
/* INCLUDES *****************************************************************/
#include <rtl.h>
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
typedef NTSTATUS (STDCALL *KERNEL_CALLBACK_FUNCTION)(PVOID Argument,
ULONG ArgumentLength);
/* FUNCTIONS *****************************************************************/
VOID STDCALL
KiUserCallbackDispatcher(ULONG RoutineIndex,
PVOID Argument,
ULONG ArgumentLength)
{
PPEB Peb;
NTSTATUS Status;
KERNEL_CALLBACK_FUNCTION Callback;
Peb = NtCurrentPeb();
Callback = (KERNEL_CALLBACK_FUNCTION)Peb->KernelCallbackTable[RoutineIndex];
Status = Callback(Argument, ArgumentLength);
ZwCallbackReturn(NULL, 0, Status);
}

653
reactos/lib/ntdll/rtl/critical.c → reactos/lib/rtl/critical.c
View file

@ -1,23 +1,19 @@
/* $Id$
*
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: lib/ntdll/rtl/critical.c
* FILE: lib/rtl/critical.c
* PURPOSE: Critical sections
* UPDATE HISTORY:
* Created 30/09/98
* Rewritten ROS version, based on WINE code plus
* some fixes useful only for ROS right now - 03/01/05
* PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
* Gunnar Dalsnes
*/
/* INCLUDES ******************************************************************/
/* INCLUDES *****************************************************************/
#include <rtl.h>
#include <ntdll.h>
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
#define MAX_STATIC_CS_DEBUG_OBJECTS 64
static RTL_CRITICAL_SECTION RtlCriticalSectionLock;
@ -26,6 +22,308 @@ static BOOLEAN RtlpCritSectInitialized = FALSE;
static RTL_CRITICAL_SECTION_DEBUG RtlpStaticDebugInfo[MAX_STATIC_CS_DEBUG_OBJECTS];
static BOOLEAN RtlpDebugInfoFreeList[MAX_STATIC_CS_DEBUG_OBJECTS];
/* FUNCTIONS *****************************************************************/
/*++
* RtlpCreateCriticalSectionSem
*
* Checks if an Event has been created for the critical section.
*
* Params:
* None
*
* Returns:
* None. Raises an exception if the system call failed.
*
* Remarks:
* None
*
*--*/
VOID
STDCALL
RtlpCreateCriticalSectionSem(PRTL_CRITICAL_SECTION CriticalSection)
{
HANDLE hEvent = CriticalSection->LockSemaphore;
HANDLE hNewEvent;
NTSTATUS Status;
/* Chevk if we have an event */
if (!hEvent) {
/* No, so create it */
if (!NT_SUCCESS(Status = NtCreateEvent(&hNewEvent,
EVENT_ALL_ACCESS,
NULL,
SynchronizationEvent,
FALSE))) {
/* We failed, this is bad... */
DPRINT1("Failed to Create Event!\n");
InterlockedDecrement(&CriticalSection->LockCount);
RtlRaiseStatus(Status);
return;
}
DPRINT("Created Event: %x \n", hNewEvent);
if ((hEvent = InterlockedCompareExchangePointer((PVOID*)&CriticalSection->LockSemaphore,
(PVOID)hNewEvent,
0))) {
/* Some just created an event */
DPRINT("Closing already created event: %x\n", hNewEvent);
NtClose(hNewEvent);
}
}
return;
}
/*++
* RtlpWaitForCriticalSection
*
* Slow path of RtlEnterCriticalSection. Waits on an Event Object.
*
* Params:
* CriticalSection - Critical section to acquire.
*
* Returns:
* STATUS_SUCCESS, or raises an exception if a deadlock is occuring.
*
* Remarks:
* None
*
*--*/
NTSTATUS
STDCALL
RtlpWaitForCriticalSection(PRTL_CRITICAL_SECTION CriticalSection)
{
NTSTATUS Status;
EXCEPTION_RECORD ExceptionRecord;
BOOLEAN LastChance = FALSE;
LARGE_INTEGER Timeout;
/* Wait 2.5 minutes */
Timeout.QuadPart = 150000L * (ULONGLONG)10000;
Timeout.QuadPart = -Timeout.QuadPart;
/* ^^ HACK HACK HACK. Good way:
Timeout = &NtCurrentPeb()->CriticalSectionTimeout */
/* Do we have an Event yet? */
if (!CriticalSection->LockSemaphore) {
RtlpCreateCriticalSectionSem(CriticalSection);
}
/* Increase the Debug Entry count */
DPRINT("Waiting on Critical Section Event: %x %x\n",
CriticalSection,
CriticalSection->LockSemaphore);
CriticalSection->DebugInfo->EntryCount++;
for (;;) {
/* Increase the number of times we've had contention */
CriticalSection->DebugInfo->ContentionCount++;
/* Wait on the Event */
Status = NtWaitForSingleObject(CriticalSection->LockSemaphore,
FALSE,
&Timeout);
/* We have Timed out */
if (Status == STATUS_TIMEOUT) {
/* Is this the 2nd time we've timed out? */
if (LastChance) {
DPRINT1("Deadlock: %x\n", CriticalSection);
/* Yes it is, we are raising an exception */
ExceptionRecord.ExceptionCode = STATUS_POSSIBLE_DEADLOCK;
ExceptionRecord.ExceptionFlags = 0;
ExceptionRecord.ExceptionRecord = NULL;
ExceptionRecord.ExceptionAddress = RtlRaiseException;
ExceptionRecord.NumberParameters = 1;
ExceptionRecord.ExceptionInformation[0] = (ULONG_PTR)CriticalSection;
RtlRaiseException(&ExceptionRecord);
}
/* One more try */
LastChance = TRUE;
} else {
/* If we are here, everything went fine */
return STATUS_SUCCESS;
}
}
}
/*++
* RtlpUnWaitCriticalSection
*
* Slow path of RtlLeaveCriticalSection. Fires an Event Object.
*
* Params:
* CriticalSection - Critical section to release.
*
* Returns:
* None. Raises an exception if the system call failed.
*
* Remarks:
* None
*
*--*/
VOID
STDCALL
RtlpUnWaitCriticalSection(PRTL_CRITICAL_SECTION CriticalSection)
{
NTSTATUS Status;
/* Do we have an Event yet? */
if (!CriticalSection->LockSemaphore) {
RtlpCreateCriticalSectionSem(CriticalSection);
}
/* Signal the Event */
DPRINT("Signaling Critical Section Event: %x, %x\n",
CriticalSection,
CriticalSection->LockSemaphore);
Status = NtSetEvent(CriticalSection->LockSemaphore, NULL);
if (!NT_SUCCESS(Status)) {
/* We've failed */
DPRINT1("Signaling Failed for: %x, %x, %x\n",
CriticalSection,
CriticalSection->LockSemaphore,
Status);
RtlRaiseStatus(Status);
}
}
/*++
* RtlpInitDeferedCriticalSection
*
* Initializes the Critical Section implementation.
*
* Params:
* None
*
* Returns:
* None.
*
* Remarks:
* After this call, the Process Critical Section list is protected.
*
*--*/
VOID
STDCALL
RtlpInitDeferedCriticalSection(VOID)
{
/* Initialize the Process Critical Section List */
InitializeListHead(&RtlCriticalSectionList);
/* Initialize the CS Protecting the List */
RtlInitializeCriticalSection(&RtlCriticalSectionLock);
/* It's now safe to enter it */
RtlpCritSectInitialized = TRUE;
}
/*++
* RtlpAllocateDebugInfo
*
* Finds or allocates memory for a Critical Section Debug Object
*
* Params:
* None
*
* Returns:
* A pointer to an empty Critical Section Debug Object.
*
* Remarks:
* For optimization purposes, the first 64 entries can be cached. From
* then on, future Critical Sections will allocate memory from the heap.
*
*--*/
PRTL_CRITICAL_SECTION_DEBUG
STDCALL
RtlpAllocateDebugInfo(VOID)
{
ULONG i;
/* Try to allocate from our buffer first */
for (i = 0; i < MAX_STATIC_CS_DEBUG_OBJECTS; i++) {
/* Check if Entry is free */
if (!RtlpDebugInfoFreeList[i]) {
/* Mark entry in use */
DPRINT("Using entry: %d. Buffer: %x\n", i, &RtlpStaticDebugInfo[i]);
RtlpDebugInfoFreeList[i] = TRUE;
/* Use free entry found */
return &RtlpStaticDebugInfo[i];
}
}
/* We are out of static buffer, allocate dynamic */
return RtlAllocateHeap(NtCurrentPeb()->ProcessHeap,
0,
sizeof(RTL_CRITICAL_SECTION_DEBUG));
}
/*++
* RtlpFreeDebugInfo
*
* Frees the memory for a Critical Section Debug Object
*
* Params:
* DebugInfo - Pointer to Critical Section Debug Object to free.
*
* Returns:
* None.
*
* Remarks:
* If the pointer is part of the static buffer, then the entry is made
* free again. If not, the object is de-allocated from the heap.
*
*--*/
VOID
STDCALL
RtlpFreeDebugInfo(PRTL_CRITICAL_SECTION_DEBUG DebugInfo)
{
ULONG EntryId;
/* Is it part of our cached entries? */
if ((DebugInfo >= RtlpStaticDebugInfo) &&
(DebugInfo <= &RtlpStaticDebugInfo[MAX_STATIC_CS_DEBUG_OBJECTS-1])) {
/* Yes. zero it out */
RtlZeroMemory(DebugInfo, sizeof(RTL_CRITICAL_SECTION_DEBUG));
/* Mark as free */
EntryId = (DebugInfo - RtlpStaticDebugInfo);
DPRINT("Freeing from Buffer: %x. Entry: %d inside Process: %x\n",
DebugInfo,
EntryId,
NtCurrentTeb()->Cid.UniqueProcess);
RtlpDebugInfoFreeList[EntryId] = FALSE;
} else {
/* It's a dynamic one, so free from the heap */
DPRINT("Freeing from Heap: %x inside Process: %x\n",
DebugInfo,
NtCurrentTeb()->Cid.UniqueProcess);
RtlFreeHeap(NtCurrentPeb()->ProcessHeap, 0, DebugInfo);
}
}
/*++
* RtlDeleteCriticalSection
* @implemented NT4
@ -44,8 +342,7 @@ static BOOLEAN RtlpDebugInfoFreeList[MAX_STATIC_CS_DEBUG_OBJECTS];
*--*/
NTSTATUS
STDCALL
RtlDeleteCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection)
RtlDeleteCriticalSection(PRTL_CRITICAL_SECTION CriticalSection)
{
NTSTATUS Status = STATUS_SUCCESS;
@ -97,10 +394,8 @@ RtlDeleteCriticalSection(
*--*/
DWORD
STDCALL
RtlSetCriticalSectionSpinCount(
PRTL_CRITICAL_SECTION CriticalSection,
ULONG SpinCount
)
RtlSetCriticalSectionSpinCount(PRTL_CRITICAL_SECTION CriticalSection,
ULONG SpinCount)
{
ULONG OldCount = CriticalSection->SpinCount;
@ -127,8 +422,7 @@ RtlSetCriticalSectionSpinCount(
*--*/
NTSTATUS
STDCALL
RtlEnterCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection)
RtlEnterCriticalSection(PRTL_CRITICAL_SECTION CriticalSection)
{
HANDLE Thread = (HANDLE)NtCurrentTeb()->Cid.UniqueThread;
@ -185,8 +479,7 @@ RtlEnterCriticalSection(
*--*/
NTSTATUS
STDCALL
RtlInitializeCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection)
RtlInitializeCriticalSection(PRTL_CRITICAL_SECTION CriticalSection)
{
/* Call the Main Function */
return RtlInitializeCriticalSectionAndSpinCount(CriticalSection, 0);
@ -212,9 +505,8 @@ RtlInitializeCriticalSection(
*--*/
NTSTATUS
STDCALL
RtlInitializeCriticalSectionAndSpinCount (
PRTL_CRITICAL_SECTION CriticalSection,
ULONG SpinCount)
RtlInitializeCriticalSectionAndSpinCount(PRTL_CRITICAL_SECTION CriticalSection,
ULONG SpinCount)
{
PRTL_CRITICAL_SECTION_DEBUG CritcalSectionDebugData;
@ -299,8 +591,7 @@ RtlInitializeCriticalSectionAndSpinCount (
*--*/
NTSTATUS
STDCALL
RtlLeaveCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection)
RtlLeaveCriticalSection(PRTL_CRITICAL_SECTION CriticalSection)
{
#ifndef NDEBUG
HANDLE Thread = (HANDLE)NtCurrentTeb()->Cid.UniqueThread;
@ -358,8 +649,7 @@ RtlLeaveCriticalSection(
*--*/
BOOLEAN
STDCALL
RtlTryEnterCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection)
RtlTryEnterCriticalSection(PRTL_CRITICAL_SECTION CriticalSection)
{
/* Try to take control */
if (InterlockedCompareExchange(&CriticalSection->LockCount,
@ -383,311 +673,4 @@ RtlTryEnterCriticalSection(
return FALSE;
}
/*++
* RtlpWaitForCriticalSection
*
* Slow path of RtlEnterCriticalSection. Waits on an Event Object.
*
* Params:
* CriticalSection - Critical section to acquire.
*
* Returns:
* STATUS_SUCCESS, or raises an exception if a deadlock is occuring.
*
* Remarks:
* None
*
*--*/
NTSTATUS
STDCALL
RtlpWaitForCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection)
{
NTSTATUS Status;
EXCEPTION_RECORD ExceptionRecord;
BOOLEAN LastChance = FALSE;
LARGE_INTEGER Timeout;
/* Wait 2.5 minutes */
Timeout.QuadPart = 150000L * (ULONGLONG)10000;
Timeout.QuadPart = -Timeout.QuadPart;
/* ^^ HACK HACK HACK. Good way:
Timeout = &NtCurrentPeb()->CriticalSectionTimeout */
/* Do we have an Event yet? */
if (!CriticalSection->LockSemaphore) {
RtlpCreateCriticalSectionSem(CriticalSection);
}
/* Increase the Debug Entry count */
DPRINT("Waiting on Critical Section Event: %x %x\n",
CriticalSection,
CriticalSection->LockSemaphore);
CriticalSection->DebugInfo->EntryCount++;
for (;;) {
/* Increase the number of times we've had contention */
CriticalSection->DebugInfo->ContentionCount++;
/* Wait on the Event */
Status = NtWaitForSingleObject(CriticalSection->LockSemaphore,
FALSE,
&Timeout);
/* We have Timed out */
if (Status == STATUS_TIMEOUT) {
/* Is this the 2nd time we've timed out? */
if (LastChance) {
DPRINT1("Deadlock: %x\n", CriticalSection);
/* Yes it is, we are raising an exception */
ExceptionRecord.ExceptionCode = STATUS_POSSIBLE_DEADLOCK;
ExceptionRecord.ExceptionFlags = 0;
ExceptionRecord.ExceptionRecord = NULL;
ExceptionRecord.ExceptionAddress = RtlRaiseException;
ExceptionRecord.NumberParameters = 1;
ExceptionRecord.ExceptionInformation[0] = (ULONG_PTR)CriticalSection;
RtlRaiseException(&ExceptionRecord);
}
/* One more try */
LastChance = TRUE;
} else {
/* If we are here, everything went fine */
return STATUS_SUCCESS;
}
}
}
/*++
* RtlpUnWaitCriticalSection
*
* Slow path of RtlLeaveCriticalSection. Fires an Event Object.
*
* Params:
* CriticalSection - Critical section to release.
*
* Returns:
* None. Raises an exception if the system call failed.
*
* Remarks:
* None
*
*--*/
VOID
STDCALL
RtlpUnWaitCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection)
{
NTSTATUS Status;
/* Do we have an Event yet? */
if (!CriticalSection->LockSemaphore) {
RtlpCreateCriticalSectionSem(CriticalSection);
}
/* Signal the Event */
DPRINT("Signaling Critical Section Event: %x, %x\n",
CriticalSection,
CriticalSection->LockSemaphore);
Status = NtSetEvent(CriticalSection->LockSemaphore, NULL);
if (!NT_SUCCESS(Status)) {
/* We've failed */
DPRINT1("Signaling Failed for: %x, %x, %x\n",
CriticalSection,
CriticalSection->LockSemaphore,
Status);
RtlRaiseStatus(Status);
}
}
/*++
* RtlpCreateCriticalSectionSem
*
* Checks if an Event has been created for the critical section.
*
* Params:
* None
*
* Returns:
* None. Raises an exception if the system call failed.
*
* Remarks:
* None
*
*--*/
VOID
STDCALL
RtlpCreateCriticalSectionSem(
PRTL_CRITICAL_SECTION CriticalSection)
{
HANDLE hEvent = CriticalSection->LockSemaphore;
HANDLE hNewEvent;
NTSTATUS Status;
/* Chevk if we have an event */
if (!hEvent) {
/* No, so create it */
if (!NT_SUCCESS(Status = NtCreateEvent(&hNewEvent,
EVENT_ALL_ACCESS,
NULL,
SynchronizationEvent,
FALSE))) {
/* We failed, this is bad... */
DPRINT1("Failed to Create Event!\n");
InterlockedDecrement(&CriticalSection->LockCount);
RtlRaiseStatus(Status);
return;
}
DPRINT("Created Event: %x \n", hNewEvent);
if ((hEvent = InterlockedCompareExchangePointer((PVOID*)&CriticalSection->LockSemaphore,
(PVOID)hNewEvent,
0))) {
/* Some just created an event */
DPRINT("Closing already created event: %x\n", hNewEvent);
NtClose(hNewEvent);
}
}
return;
}
/*++
* RtlpInitDeferedCriticalSection
*
* Initializes the Critical Section implementation.
*
* Params:
* None
*
* Returns:
* None.
*
* Remarks:
* After this call, the Process Critical Section list is protected.
*
*--*/
VOID
STDCALL
RtlpInitDeferedCriticalSection(
VOID)
{
/* Initialize the Process Critical Section List */
InitializeListHead(&RtlCriticalSectionList);
/* Initialize the CS Protecting the List */
RtlInitializeCriticalSection(&RtlCriticalSectionLock);
/* It's now safe to enter it */
RtlpCritSectInitialized = TRUE;
}
/*++
* RtlpAllocateDebugInfo
*
* Finds or allocates memory for a Critical Section Debug Object
*
* Params:
* None
*
* Returns:
* A pointer to an empty Critical Section Debug Object.
*
* Remarks:
* For optimization purposes, the first 64 entries can be cached. From
* then on, future Critical Sections will allocate memory from the heap.
*
*--*/
PRTL_CRITICAL_SECTION_DEBUG
STDCALL
RtlpAllocateDebugInfo(
VOID)
{
ULONG i;
/* Try to allocate from our buffer first */
for (i = 0; i < MAX_STATIC_CS_DEBUG_OBJECTS; i++) {
/* Check if Entry is free */
if (!RtlpDebugInfoFreeList[i]) {
/* Mark entry in use */
DPRINT("Using entry: %d. Buffer: %x\n", i, &RtlpStaticDebugInfo[i]);
RtlpDebugInfoFreeList[i] = TRUE;
/* Use free entry found */
return &RtlpStaticDebugInfo[i];
}
}
/* We are out of static buffer, allocate dynamic */
return RtlAllocateHeap(NtCurrentPeb()->ProcessHeap,
0,
sizeof(RTL_CRITICAL_SECTION_DEBUG));
}
/*++
* RtlpFreeDebugInfo
*
* Frees the memory for a Critical Section Debug Object
*
* Params:
* DebugInfo - Pointer to Critical Section Debug Object to free.
*
* Returns:
* None.
*
* Remarks:
* If the pointer is part of the static buffer, then the entry is made
* free again. If not, the object is de-allocated from the heap.
*
*--*/
VOID
STDCALL
RtlpFreeDebugInfo(
PRTL_CRITICAL_SECTION_DEBUG DebugInfo)
{
ULONG EntryId;
/* Is it part of our cached entries? */
if ((DebugInfo >= RtlpStaticDebugInfo) &&
(DebugInfo <= &RtlpStaticDebugInfo[MAX_STATIC_CS_DEBUG_OBJECTS-1])) {
/* Yes. zero it out */
RtlZeroMemory(DebugInfo, sizeof(RTL_CRITICAL_SECTION_DEBUG));
/* Mark as free */
EntryId = (DebugInfo - RtlpStaticDebugInfo);
DPRINT("Freeing from Buffer: %x. Entry: %d inside Process: %x\n",
DebugInfo,
EntryId,
NtCurrentTeb()->Cid.UniqueProcess);
RtlpDebugInfoFreeList[EntryId] = FALSE;
} else {
/* It's a dynamic one, so free from the heap */
DPRINT("Freeing from Heap: %x inside Process: %x\n",
DebugInfo,
NtCurrentTeb()->Cid.UniqueProcess);
RtlFreeHeap(NtCurrentPeb()->ProcessHeap, 0, DebugInfo);
}
}
/* EOF */

70
reactos/lib/rtl/heap.c
View file

@ -570,7 +570,7 @@ static BOOLEAN HEAP_InitSubHeap( HEAP *heap, PVOID address, ULONG flags,
/* Initialize critical section */
RtlInitializeCriticalSection( &heap->critSection );
RtlInitializeHeapLock( &heap->critSection );
}
/* Commit memory */
@ -937,12 +937,12 @@ int HEAP_IsInsideHeap(
return 0;
flags |= heapPtr->flags;
if (!(flags & HEAP_NO_SERIALIZE))
RtlEnterCriticalSection( &heapPtr->critSection );
RtlEnterHeapLock( &heapPtr->critSection );
ret = (((subheap = HEAP_FindSubHeap( heapPtr, ptr )) != NULL) &&
(((char *)ptr >= (char *)subheap + subheap->headerSize
+ sizeof(ARENA_INUSE))));
if (!(flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
return ret;
}
@ -1002,7 +1002,7 @@ static BOOLEAN HEAP_IsRealArena(
flags |= heapPtr->flags;
/* calling HeapLock may result in infinite recursion, so do the critsect directly */
if (!(flags & HEAP_NO_SERIALIZE))
RtlEnterCriticalSection( &heapPtr->critSection );
RtlEnterHeapLock( &heapPtr->critSection );
if (block)
{
@ -1032,7 +1032,7 @@ static BOOLEAN HEAP_IsRealArena(
ret = HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)block - 1, quiet );
if (!(flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
return ret;
}
@ -1065,7 +1065,7 @@ static BOOLEAN HEAP_IsRealArena(
}
if (!(flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
return ret;
}
@ -1105,14 +1105,14 @@ RtlCreateHeap(ULONG flags,
if (RtlpGetMode() == UserMode)
{
/* link it into the per-process heap list */
RtlEnterCriticalSection (&RtlpProcessHeapsListLock);
RtlEnterHeapLock (&RtlpProcessHeapsListLock);
heapPtr = subheap->heap;
heapPtr->next = (HEAP*)NtCurrentPeb()->ProcessHeaps;
NtCurrentPeb()->ProcessHeaps = (HANDLE)heapPtr;
NtCurrentPeb()->NumberOfHeaps++;
RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
RtlLeaveHeapLock (&RtlpProcessHeapsListLock);
}
return (HANDLE)subheap;
@ -1148,17 +1148,17 @@ RtlDestroyHeap(HANDLE heap) /* [in] Handle of heap */
return heap; /* cannot delete the main process heap */
/* remove it from the per-process list */
RtlEnterCriticalSection (&RtlpProcessHeapsListLock);
RtlEnterHeapLock (&RtlpProcessHeapsListLock);
pptr = (HEAP**)&NtCurrentPeb()->ProcessHeaps;
while (*pptr && *pptr != heapPtr) pptr = &(*pptr)->next;
if (*pptr) *pptr = (*pptr)->next;
NtCurrentPeb()->NumberOfHeaps--;
RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
RtlLeaveHeapLock (&RtlpProcessHeapsListLock);
}
RtlDeleteCriticalSection( &heapPtr->critSection );
RtlDeleteHeapLock( &heapPtr->critSection );
subheap = &heapPtr->subheap;
// We must save the flags. The first subheap is located after
// the heap structure. If we release the first subheap,
@ -1207,7 +1207,7 @@ RtlAllocateHeap(HANDLE heap, /* [in] Handle of private heap block */
flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY;
flags |= heapPtr->flags;
if (!(flags & HEAP_NO_SERIALIZE))
RtlEnterCriticalSection( &heapPtr->critSection );
RtlEnterHeapLock( &heapPtr->critSection );
size = (size + 7) & ~7;
if (size < HEAP_MIN_BLOCK_SIZE)
size = HEAP_MIN_BLOCK_SIZE;
@ -1219,7 +1219,7 @@ RtlAllocateHeap(HANDLE heap, /* [in] Handle of private heap block */
DPRINT("(%08x,%08lx,%08lx): returning NULL\n",
heap, flags, size );
if (!(flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
if (flags & HEAP_GENERATE_EXCEPTIONS)
RtlRaiseStatus( STATUS_NO_MEMORY );
return NULL;
@ -1248,7 +1248,7 @@ RtlAllocateHeap(HANDLE heap, /* [in] Handle of private heap block */
memset( pInUse + 1, ARENA_INUSE_FILLER, pInUse->size & ARENA_SIZE_MASK );
if (!(flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
DPRINT("(%08x,%08lx,%08lx): returning %p\n",
heap, flags, size, (PVOID)(pInUse + 1) );
@ -1288,11 +1288,11 @@ BOOLEAN STDCALL RtlFreeHeap(
flags &= HEAP_NO_SERIALIZE;
flags |= heapPtr->flags;
if (!(flags & HEAP_NO_SERIALIZE))
RtlEnterCriticalSection( &heapPtr->critSection );
RtlEnterHeapLock( &heapPtr->critSection );
if (!HEAP_IsRealArena( heap, HEAP_NO_SERIALIZE, ptr, QUIET ))
{
if (!(flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
DPRINT("(%08x,%08lx,%p): returning FALSE\n",
heap, flags, ptr );
return FALSE;
@ -1305,7 +1305,7 @@ BOOLEAN STDCALL RtlFreeHeap(
HEAP_MakeInUseBlockFree( subheap, pInUse, heapPtr->flags );
if (!(flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
DPRINT("(%08x,%08lx,%p): returning TRUE\n",
heap, flags, ptr );
@ -1354,11 +1354,11 @@ PVOID STDCALL RtlReAllocateHeap(
Size = HEAP_MIN_BLOCK_SIZE;
if (!(Flags & HEAP_NO_SERIALIZE))
RtlEnterCriticalSection( &heapPtr->critSection );
RtlEnterHeapLock( &heapPtr->critSection );
if (!HEAP_IsRealArena( Heap, HEAP_NO_SERIALIZE, Ptr, QUIET ))
{
if (!(Flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
DPRINT("(%08x,%08lx,%p,%08lx): returning NULL\n",
Heap, Flags, Ptr, Size );
if (Flags & HEAP_GENERATE_EXCEPTIONS)
@ -1390,7 +1390,7 @@ PVOID STDCALL RtlReAllocateHeap(
heapPtr->flags))
{
if (!(Flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
if (Flags & HEAP_GENERATE_EXCEPTIONS)
RtlRaiseStatus( STATUS_NO_MEMORY );
return NULL;
@ -1407,7 +1407,7 @@ PVOID STDCALL RtlReAllocateHeap(
!(pNew = HEAP_FindFreeBlock( heapPtr, Size, &newsubheap )))
{
if (!(Flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
if (Flags & HEAP_GENERATE_EXCEPTIONS)
RtlRaiseStatus( STATUS_NO_MEMORY );
return NULL;
@ -1450,7 +1450,7 @@ PVOID STDCALL RtlReAllocateHeap(
/* Return the new arena */
if (!(Flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
DPRINT("(%08x,%08lx,%p,%08lx): returning %p\n",
Heap, Flags, Ptr, Size, (PVOID)(pArena + 1) );
@ -1491,7 +1491,7 @@ RtlLockHeap(IN HANDLE Heap)
HEAP *heapPtr = HEAP_GetPtr( Heap );
if (!heapPtr)
return FALSE;
RtlEnterCriticalSection( &heapPtr->critSection );
RtlEnterHeapLock( &heapPtr->critSection );
return TRUE;
}
@ -1515,7 +1515,7 @@ RtlUnlockHeap(HANDLE Heap)
HEAP *heapPtr = HEAP_GetPtr( Heap );
if (!heapPtr)
return FALSE;
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
return TRUE;
}
@ -1548,7 +1548,7 @@ RtlSizeHeap(
Flags &= HEAP_NO_SERIALIZE;
Flags |= heapPtr->flags;
if (!(Flags & HEAP_NO_SERIALIZE))
RtlEnterCriticalSection( &heapPtr->critSection );
RtlEnterHeapLock( &heapPtr->critSection );
if (!HEAP_IsRealArena( Heap, HEAP_NO_SERIALIZE, Ptr, QUIET ))
{
ret = 0xffffffff;
@ -1559,7 +1559,7 @@ RtlSizeHeap(
ret = pArena->size & ARENA_SIZE_MASK;
}
if (!(Flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
DPRINT("(%08x,%08lx,%p): returning %08lx\n",
Heap, Flags, Ptr, ret );
@ -1629,7 +1629,7 @@ BOOLEAN STDCALL HeapWalk(
}
if (!(heapPtr->flags & HEAP_NO_SERIALIZE))
RtlEnterCriticalSection( &heapPtr->critSection );
RtlEnterHeapLock( &heapPtr->critSection );
/* set ptr to the next arena to be examined */
@ -1717,7 +1717,7 @@ BOOLEAN STDCALL HeapWalk(
HW_end:
if (!(heapPtr->flags & HEAP_NO_SERIALIZE))
RtlLeaveCriticalSection( &heapPtr->critSection );
RtlLeaveHeapLock( &heapPtr->critSection );
return ret;
}
@ -1735,7 +1735,7 @@ RtlInitializeHeapManager(VOID)
Peb->MaximumNumberOfHeaps = -1; /* no limit */
Peb->ProcessHeaps = NULL;
RtlInitializeCriticalSection(&RtlpProcessHeapsListLock);
RtlInitializeHeapLock(&RtlpProcessHeapsListLock);
}
@ -1749,7 +1749,7 @@ RtlEnumProcessHeaps(PHEAP_ENUMERATION_ROUTINE HeapEnumerationRoutine,
NTSTATUS Status = STATUS_SUCCESS;
HEAP** pptr;
RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
RtlEnterHeapLock(&RtlpProcessHeapsListLock);
for (pptr = (HEAP**)&NtCurrentPeb()->ProcessHeaps; *pptr; pptr = &(*pptr)->next)
{
@ -1758,7 +1758,7 @@ RtlEnumProcessHeaps(PHEAP_ENUMERATION_ROUTINE HeapEnumerationRoutine,
break;
}
RtlLeaveCriticalSection(&RtlpProcessHeapsListLock);
RtlLeaveHeapLock(&RtlpProcessHeapsListLock);
return Status;
}
@ -1774,7 +1774,7 @@ RtlGetProcessHeaps(ULONG HeapCount,
ULONG Result = 0;
HEAP ** pptr;
RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
RtlEnterHeapLock(&RtlpProcessHeapsListLock);
Result = NtCurrentPeb()->NumberOfHeaps;
@ -1787,7 +1787,7 @@ RtlGetProcessHeaps(ULONG HeapCount,
}
}
RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
RtlLeaveHeapLock (&RtlpProcessHeapsListLock);
return Result;
}
@ -1802,7 +1802,7 @@ RtlValidateProcessHeaps(VOID)
BOOLEAN Result = TRUE;
HEAP ** pptr;
RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
RtlEnterHeapLock(&RtlpProcessHeapsListLock);
for (pptr = (HEAP**)&NtCurrentPeb()->ProcessHeaps; *pptr; pptr = &(*pptr)->next)
{
@ -1813,7 +1813,7 @@ RtlValidateProcessHeaps(VOID)
}
}
RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
RtlLeaveHeapLock (&RtlpProcessHeapsListLock);
return Result;
}

13
reactos/lib/ntdll/rtl/path.c → reactos/lib/rtl/path.c
View file

@ -1,16 +1,15 @@
/* $Id$
*
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: lib/ntdll/rtl/path.c
* FILE: lib/rtl/path.c
* PURPOSE: Path and current directory functions
* UPDATE HISTORY:
* Created 03/02/00
* PROGRAMMERS:
*/
/* INCLUDES ******************************************************************/
/* INCLUDES *****************************************************************/
#include <rtl.h>
#include <ntdll.h>
#define NDEBUG
#include <debug.h>

4
reactos/lib/rtl/rtl.h
View file

@ -34,6 +34,10 @@ extern VOID FASTCALL CHECK_PAGED_CODE_RTL(char *file, int line);
PVOID STDCALL RtlpAllocateMemory(UINT Bytes, ULONG Tag);
VOID STDCALL RtlpFreeMemory(PVOID Mem, ULONG Tag);
KPROCESSOR_MODE STDCALL RtlpGetMode();
NTSTATUS STDCALL RtlDeleteHeapLock(PRTL_CRITICAL_SECTION CriticalSection);
NTSTATUS STDCALL RtlEnterHeapLock(PRTL_CRITICAL_SECTION CriticalSection);
NTSTATUS STDCALL RtlInitializeHeapLock(PRTL_CRITICAL_SECTION CriticalSection);
NTSTATUS STDCALL RtlLeaveHeapLock(PRTL_CRITICAL_SECTION CriticalSection);
#define RtlpAllocateStringMemory RtlpAllocateMemory
#define RtlpFreeStringMemory RtlpFreeMemory

5
reactos/lib/rtl/rtl.xml
View file

@ -15,14 +15,13 @@
</if>
<file>access.c</file>
<file>acl.c</file>
<file>apc.c</file>
<file>atom.c</file>
<file>bit.c</file>
<file>bitmap.c</file>
<file>bootdata.c</file>
<file>callback.c</file>
<file>compress.c</file>
<file>crc32.c</file>
<file>critical.c</file>
<file>dbgbuffer.c</file>
<file>dos8dot3.c</file>
<file>encode.c</file>
@ -40,6 +39,7 @@
<file>luid.c</file>
<file>network.c</file>
<file>nls.c</file>
<file>path.c</file>
<file>ppb.c</file>
<file>process.c</file>
<file>propvar.c</file>
@ -58,6 +58,7 @@
<file>timerqueue.c</file>
<file>unicode.c</file>
<file>unicodeprefix.c</file>
<file>vectoreh.c</file>
<file>version.c</file>
<pch>rtl.h</pch>
</module>

91
reactos/lib/ntdll/rtl/exception.c → reactos/lib/rtl/vectoreh.c
View file

@ -1,20 +1,15 @@
/* $Id$
*
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: User-mode exception support
* FILE: lib/ntdll/rtl/exception.c
* PROGRAMERS: David Welch <welch@cwcom.net>
* Skywing <skywing@valhallalegends.com>
* KJK::Hyperion <noog@libero.it>
* UPDATES: Skywing, 09/11/2003: Implemented RtlRaiseException and
* KiUserRaiseExceptionDispatcher.
* KJK::Hyperion, 22/06/2003: Moved common parts to rtl
* PROJECT: ReactOS sysem libraries
* PURPOSE: Vectored Exception Handling
* FILE: lib/rtl/vectoreh.c
* PROGRAMERS: Thomas Weidenmueller
*/
/* INCLUDES *****************************************************************/
#include <ntdll.h>
#include <rtl.h>
#define NDEBUG
#include <debug.h>
@ -33,17 +28,6 @@ typedef struct _RTL_VECTORED_EXCEPTION_HANDLER
/* FUNCTIONS ***************************************************************/
VOID STDCALL
RtlBaseProcessStart(PTHREAD_START_ROUTINE StartAddress,
PVOID Parameter);
__declspec(dllexport)
PRTL_BASE_PROCESS_START_ROUTINE RtlBaseProcessStartRoutine = RtlBaseProcessStart;
ULONG
RtlpDispatchException(IN PEXCEPTION_RECORD ExceptionRecord,
IN PCONTEXT Context);
EXCEPTION_DISPOSITION
RtlpExecuteVectoredExceptionHandlers(IN PEXCEPTION_RECORD ExceptionRecord,
IN PCONTEXT Context)
@ -79,67 +63,6 @@ RtlpExecuteVectoredExceptionHandlers(IN PEXCEPTION_RECORD ExceptionRecord,
return ExceptionContinueExecution;
}
VOID STDCALL
KiUserExceptionDispatcher(PEXCEPTION_RECORD ExceptionRecord,
PCONTEXT Context)
{
EXCEPTION_RECORD NestedExceptionRecord;
NTSTATUS Status;
if(RtlpExecuteVectoredExceptionHandlers(ExceptionRecord,
Context) != ExceptionContinueExecution)
{
Status = NtContinue(Context, FALSE);
}
else
{
if(RtlpDispatchException(ExceptionRecord, Context) != ExceptionContinueExecution)
{
Status = NtContinue(Context, FALSE);
}
else
{
Status = NtRaiseException(ExceptionRecord, Context, FALSE);
}
}
NestedExceptionRecord.ExceptionCode = Status;
NestedExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
NestedExceptionRecord.ExceptionRecord = ExceptionRecord;
NestedExceptionRecord.NumberParameters = Status;
RtlRaiseException(&NestedExceptionRecord);
}
/*
* @implemented
*/
VOID STDCALL
KiRaiseUserExceptionDispatcher(VOID)
{
EXCEPTION_RECORD ExceptionRecord;
ExceptionRecord.ExceptionCode = ((PTEB)NtCurrentTeb())->ExceptionCode;
ExceptionRecord.ExceptionFlags = 0;
ExceptionRecord.ExceptionRecord = NULL;
ExceptionRecord.NumberParameters = 0;
RtlRaiseException(&ExceptionRecord);
}
VOID STDCALL
RtlBaseProcessStart(PTHREAD_START_ROUTINE StartAddress,
PVOID Parameter)
{
NTSTATUS ExitStatus = STATUS_SUCCESS;
ExitStatus = (NTSTATUS) (StartAddress)(Parameter);
NtTerminateProcess(NtCurrentProcess(), ExitStatus);
}
VOID
RtlpInitializeVectoredExceptionHandling(VOID)
{

38
reactos/ntoskrnl/rtl/libsupp.c
View file

@ -79,25 +79,15 @@ RtlpCurrentPeb(VOID)
NTSTATUS
STDCALL
RtlDeleteCriticalSection(
RtlDeleteHeapLock(
PRTL_CRITICAL_SECTION CriticalSection)
{
return STATUS_SUCCESS;
}
DWORD
STDCALL
RtlSetCriticalSectionSpinCount(
PRTL_CRITICAL_SECTION CriticalSection,
DWORD SpinCount
)
{
return 0;
}
NTSTATUS
STDCALL
RtlEnterCriticalSection(
RtlEnterHeapLock(
PRTL_CRITICAL_SECTION CriticalSection)
{
ExAcquireFastMutex((PFAST_MUTEX) CriticalSection);
@ -106,7 +96,7 @@ RtlEnterCriticalSection(
NTSTATUS
STDCALL
RtlInitializeCriticalSection(
RtlInitializeHeapLock(
PRTL_CRITICAL_SECTION CriticalSection)
{
ExInitializeFastMutex((PFAST_MUTEX)CriticalSection );
@ -115,33 +105,13 @@ RtlInitializeCriticalSection(
NTSTATUS
STDCALL
RtlLeaveCriticalSection(
RtlLeaveHeapLock(
PRTL_CRITICAL_SECTION CriticalSection)
{
ExReleaseFastMutex((PFAST_MUTEX) CriticalSection );
return STATUS_SUCCESS;
}
BOOLEAN
STDCALL
RtlTryEnterCriticalSection(
PRTL_CRITICAL_SECTION CriticalSection)
{
return ExTryToAcquireFastMutex((PFAST_MUTEX) CriticalSection );
}
NTSTATUS
STDCALL
RtlInitializeCriticalSectionAndSpinCount(
PRTL_CRITICAL_SECTION CriticalSection,
ULONG SpinCount)
{
ExInitializeFastMutex((PFAST_MUTEX)CriticalSection );
return STATUS_SUCCESS;
}
#ifdef DBG
VOID FASTCALL
CHECK_PAGED_CODE_RTL(char *file, int line)