Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-02 10:45:24 +00:00
Code Issues Packages Projects Releases 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);
}

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

File diff suppressed because it is too large Load diff

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>

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

@ -1,221 +1,144 @@
/* $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
*/
/* INCLUDES *****************************************************************/
#include <ntdll.h>
#define NDEBUG
#include <debug.h>
static RTL_CRITICAL_SECTION RtlpVectoredExceptionLock;
static LIST_ENTRY RtlpVectoredExceptionHead;
typedef struct _RTL_VECTORED_EXCEPTION_HANDLER
{
LIST_ENTRY ListEntry;
PVECTORED_EXCEPTION_HANDLER VectoredHandler;
} RTL_VECTORED_EXCEPTION_HANDLER, *PRTL_VECTORED_EXCEPTION_HANDLER;
/* FIXME - stupid ld won't resolve RtlDecodePointer! Since their implementation
is the same just use RtlEncodePointer for now! */
#define RtlDecodePointer RtlEncodePointer
/* 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)
{
PLIST_ENTRY CurrentEntry;
PRTL_VECTORED_EXCEPTION_HANDLER veh;
PVECTORED_EXCEPTION_HANDLER VectoredHandler;
EXCEPTION_POINTERS ExceptionInfo;
ExceptionInfo.ExceptionRecord = ExceptionRecord;
ExceptionInfo.ContextRecord = Context;
if(RtlpVectoredExceptionHead.Flink != &RtlpVectoredExceptionHead)
{
RtlEnterCriticalSection(&RtlpVectoredExceptionLock);
for(CurrentEntry = RtlpVectoredExceptionHead.Flink;
CurrentEntry != &RtlpVectoredExceptionHead;
CurrentEntry = CurrentEntry->Flink)
{
veh = CONTAINING_RECORD(CurrentEntry,
RTL_VECTORED_EXCEPTION_HANDLER,
ListEntry);
VectoredHandler = RtlDecodePointer(veh->VectoredHandler);
if(VectoredHandler(&ExceptionInfo) == EXCEPTION_CONTINUE_EXECUTION)
{
RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
return ExceptionContinueSearch;
}
}
RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
}
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)
{
InitializeListHead(&RtlpVectoredExceptionHead);
RtlInitializeCriticalSection(&RtlpVectoredExceptionLock);
}
/*
* @implemented
*/
PVOID STDCALL
RtlAddVectoredExceptionHandler(IN ULONG FirstHandler,
IN PVECTORED_EXCEPTION_HANDLER VectoredHandler)
{
PRTL_VECTORED_EXCEPTION_HANDLER veh;
veh = RtlAllocateHeap(RtlGetProcessHeap(),
0,
sizeof(RTL_VECTORED_EXCEPTION_HANDLER));
if(veh != NULL)
{
veh->VectoredHandler = RtlEncodePointer(VectoredHandler);
RtlEnterCriticalSection(&RtlpVectoredExceptionLock);
if(FirstHandler != 0)
{
InsertHeadList(&RtlpVectoredExceptionHead,
&veh->ListEntry);
}
else
{
InsertTailList(&RtlpVectoredExceptionHead,
&veh->ListEntry);
}
RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
}
return veh;
}
/*
* @implemented
*/
ULONG STDCALL
RtlRemoveVectoredExceptionHandler(IN PVOID VectoredHandlerHandle)
{
PLIST_ENTRY CurrentEntry;
PRTL_VECTORED_EXCEPTION_HANDLER veh = NULL;
ULONG Removed = FALSE;
RtlEnterCriticalSection(&RtlpVectoredExceptionLock);
for(CurrentEntry = RtlpVectoredExceptionHead.Flink;
CurrentEntry != &RtlpVectoredExceptionHead;
CurrentEntry = CurrentEntry->Flink)
{
veh = CONTAINING_RECORD(CurrentEntry,
RTL_VECTORED_EXCEPTION_HANDLER,
ListEntry);
if(veh == VectoredHandlerHandle)
{
RemoveEntryList(&veh->ListEntry);
Removed = TRUE;
break;
}
}
RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
if(Removed)
{
RtlFreeHeap(RtlGetProcessHeap(),
0,
veh);
}
return Removed;
}
/* EOF */
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS sysem libraries
* PURPOSE: Vectored Exception Handling
* FILE: lib/rtl/vectoreh.c
* PROGRAMERS: Thomas Weidenmueller
*/
/* INCLUDES *****************************************************************/
#include <rtl.h>
#define NDEBUG
#include <debug.h>
static RTL_CRITICAL_SECTION RtlpVectoredExceptionLock;
static LIST_ENTRY RtlpVectoredExceptionHead;
typedef struct _RTL_VECTORED_EXCEPTION_HANDLER
{
LIST_ENTRY ListEntry;
PVECTORED_EXCEPTION_HANDLER VectoredHandler;
} RTL_VECTORED_EXCEPTION_HANDLER, *PRTL_VECTORED_EXCEPTION_HANDLER;
/* FIXME - stupid ld won't resolve RtlDecodePointer! Since their implementation
is the same just use RtlEncodePointer for now! */
#define RtlDecodePointer RtlEncodePointer
/* FUNCTIONS ***************************************************************/
EXCEPTION_DISPOSITION
RtlpExecuteVectoredExceptionHandlers(IN PEXCEPTION_RECORD ExceptionRecord,
IN PCONTEXT Context)
{
PLIST_ENTRY CurrentEntry;
PRTL_VECTORED_EXCEPTION_HANDLER veh;
PVECTORED_EXCEPTION_HANDLER VectoredHandler;
EXCEPTION_POINTERS ExceptionInfo;
ExceptionInfo.ExceptionRecord = ExceptionRecord;
ExceptionInfo.ContextRecord = Context;
if(RtlpVectoredExceptionHead.Flink != &RtlpVectoredExceptionHead)
{
RtlEnterCriticalSection(&RtlpVectoredExceptionLock);
for(CurrentEntry = RtlpVectoredExceptionHead.Flink;
CurrentEntry != &RtlpVectoredExceptionHead;
CurrentEntry = CurrentEntry->Flink)
{
veh = CONTAINING_RECORD(CurrentEntry,
RTL_VECTORED_EXCEPTION_HANDLER,
ListEntry);
VectoredHandler = RtlDecodePointer(veh->VectoredHandler);
if(VectoredHandler(&ExceptionInfo) == EXCEPTION_CONTINUE_EXECUTION)
{
RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
return ExceptionContinueSearch;
}
}
RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
}
return ExceptionContinueExecution;
}
VOID
RtlpInitializeVectoredExceptionHandling(VOID)
{
InitializeListHead(&RtlpVectoredExceptionHead);
RtlInitializeCriticalSection(&RtlpVectoredExceptionLock);
}
/*
* @implemented
*/
PVOID STDCALL
RtlAddVectoredExceptionHandler(IN ULONG FirstHandler,
IN PVECTORED_EXCEPTION_HANDLER VectoredHandler)
{
PRTL_VECTORED_EXCEPTION_HANDLER veh;
veh = RtlAllocateHeap(RtlGetProcessHeap(),
0,
sizeof(RTL_VECTORED_EXCEPTION_HANDLER));
if(veh != NULL)
{
veh->VectoredHandler = RtlEncodePointer(VectoredHandler);
RtlEnterCriticalSection(&RtlpVectoredExceptionLock);
if(FirstHandler != 0)
{
InsertHeadList(&RtlpVectoredExceptionHead,
&veh->ListEntry);
}
else
{
InsertTailList(&RtlpVectoredExceptionHead,
&veh->ListEntry);
}
RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
}
return veh;
}
/*
* @implemented
*/
ULONG STDCALL
RtlRemoveVectoredExceptionHandler(IN PVOID VectoredHandlerHandle)
{
PLIST_ENTRY CurrentEntry;
PRTL_VECTORED_EXCEPTION_HANDLER veh = NULL;
ULONG Removed = FALSE;
RtlEnterCriticalSection(&RtlpVectoredExceptionLock);
for(CurrentEntry = RtlpVectoredExceptionHead.Flink;
CurrentEntry != &RtlpVectoredExceptionHead;
CurrentEntry = CurrentEntry->Flink)
{
veh = CONTAINING_RECORD(CurrentEntry,
RTL_VECTORED_EXCEPTION_HANDLER,
ListEntry);
if(veh == VectoredHandlerHandle)
{
RemoveEntryList(&veh->ListEntry);
Removed = TRUE;
break;
}
}
RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
if(Removed)
{
RtlFreeHeap(RtlGetProcessHeap(),
0,
veh);
}
return Removed;
}
/* EOF */

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)