Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-06-25 19:39:42 +00:00
Code Issues Projects Releases Packages Wiki Activity

RtlInitializeCriticalSection() returns NTSTATUS

Browse source 
svn path=/trunk/; revision=1618
This commit is contained in:
Eric Kohl 2001-02-11 00:15:56 +00:00
parent 9359db14a0
commit b91cda60d8
2 changed files with 61 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

16
reactos/include/ntdll/rtl.h
View file

@ -1,4 +1,4 @@
/* $Id: rtl.h,v 1.22 2001/02/10 22:51:07 dwelch Exp $ /* $Id: rtl.h,v 1.23 2001/02/11 00:14:25 ekohl Exp $
* *
*/ */
@ -44,31 +44,31 @@ typedef struct _RTL_PROCESS_INFO
VOID VOID
STDCALL STDCALL
RtlDeleteCriticalSection ( RtlDeleteCriticalSection (
LPCRITICAL_SECTION lpCriticalSection PCRITICAL_SECTION CriticalSection
); );
VOID VOID
STDCALL STDCALL
RtlEnterCriticalSection ( RtlEnterCriticalSection (
LPCRITICAL_SECTION lpCriticalSection PCRITICAL_SECTION CriticalSection
); );
VOID NTSTATUS
STDCALL STDCALL
RtlInitializeCriticalSection ( RtlInitializeCriticalSection (
LPCRITICAL_SECTION pcritical PCRITICAL_SECTION CriticalSection
); );
VOID VOID
STDCALL STDCALL
RtlLeaveCriticalSection ( RtlLeaveCriticalSection (
LPCRITICAL_SECTION lpCriticalSection PCRITICAL_SECTION CriticalSection
); );
BOOLEAN BOOLEAN
STDCALL STDCALL
RtlTryEntryCriticalSection ( RtlTryEnterCriticalSection (
LPCRITICAL_SECTION lpCriticalSection PCRITICAL_SECTION CriticalSection
); );
UINT UINT

105
reactos/lib/ntdll/rtl/critical.c
View file

@ -1,4 +1,4 @@
/* $Id: critical.c,v 1.9 2001/01/21 00:07:51 phreak Exp $ /* $Id: critical.c,v 1.10 2001/02/11 00:15:56 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -12,36 +12,37 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <ntdll/rtl.h> #include <ntdll/rtl.h>
#include <ntos/synch.h>
#include <ntdll/ntdll.h> #include <ntdll/ntdll.h>
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
VOID STDCALL VOID STDCALL
RtlDeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection) RtlDeleteCriticalSection(PCRITICAL_SECTION CriticalSection)
{ {
NtClose(lpCriticalSection->LockSemaphore); NtClose(CriticalSection->LockSemaphore);
lpCriticalSection->Reserved = -1; CriticalSection->Reserved = -1;
} }
VOID STDCALL VOID STDCALL
RtlEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection) RtlEnterCriticalSection(PCRITICAL_SECTION CriticalSection)
{ {
HANDLE Thread = (HANDLE)NtCurrentTeb()->Cid.UniqueThread; HANDLE Thread = (HANDLE)NtCurrentTeb()->Cid.UniqueThread;
ULONG ret; ULONG ret;
if (InterlockedIncrement(&lpCriticalSection->LockCount)) if (InterlockedIncrement(&CriticalSection->LockCount))
{ {
NTSTATUS Status; NTSTATUS Status;
if (lpCriticalSection->OwningThread == Thread) if (CriticalSection->OwningThread == Thread)
{ {
lpCriticalSection->RecursionCount++; CriticalSection->RecursionCount++;
return; return;
} }
// DbgPrint("Entering wait for critical section\n"); // DbgPrint("Entering wait for critical section\n");
Status = NtWaitForSingleObject(lpCriticalSection->LockSemaphore, Status = NtWaitForSingleObject(CriticalSection->LockSemaphore,
0, FALSE); 0, FALSE);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
@ -50,73 +51,70 @@ RtlEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
} }
// DbgPrint("Left wait for critical section\n"); // DbgPrint("Left wait for critical section\n");
} }
lpCriticalSection->OwningThread = Thread; CriticalSection->OwningThread = Thread;
lpCriticalSection->RecursionCount = 1; CriticalSection->RecursionCount = 1;
#if 0 #if 0
if ((ret = InterlockedIncrement(&(lpCriticalSection->LockCount) )) != 1) if ((ret = InterlockedIncrement(&(CriticalSection->LockCount) )) != 1)
{ {
if (lpCriticalSection->OwningThread != Thread) if (CriticalSection->OwningThread != Thread)
{ {
NtWaitForSingleObject(lpCriticalSection->LockSemaphore, NtWaitForSingleObject(CriticalSection->LockSemaphore,
0, 0,
FALSE); FALSE);
lpCriticalSection->OwningThread = Thread; CriticalSection->OwningThread = Thread;
} }
} }
else else
{ {
lpCriticalSection->OwningThread = Thread; CriticalSection->OwningThread = Thread;
} }
lpCriticalSection->RecursionCount++; CriticalSection->RecursionCount++;
#endif #endif
} }
VOID STDCALL NTSTATUS STDCALL
RtlInitializeCriticalSection(LPCRITICAL_SECTION pcritical) RtlInitializeCriticalSection(PCRITICAL_SECTION CriticalSection)
{ {
NTSTATUS Status; NTSTATUS Status;
pcritical->LockCount = -1; CriticalSection->LockCount = -1;
pcritical->RecursionCount = 0; CriticalSection->RecursionCount = 0;
Status = NtCreateSemaphore(&pcritical->LockSemaphore, CriticalSection->OwningThread = (HANDLE)0;
STANDARD_RIGHTS_ALL, CriticalSection->Reserved = 0;
NULL,
0, Status = NtCreateSemaphore(&CriticalSection->LockSemaphore,
SEMAPHORE_ALL_ACCESS,
NULL,
0,
1); 1);
if (!NT_SUCCESS(Status)) return Status;
{
DbgPrint("Failed to create semaphore (Status %x)\n", Status);
/* FIXME: Throw exception */
}
pcritical->OwningThread = (HANDLE)-1; // critical section has no owner yet
pcritical->Reserved = 0;
} }
VOID STDCALL VOID STDCALL
RtlLeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection) RtlLeaveCriticalSection(PCRITICAL_SECTION CriticalSection)
{ {
HANDLE Thread = (HANDLE)NtCurrentTeb()->Cid.UniqueThread; HANDLE Thread = (HANDLE)NtCurrentTeb()->Cid.UniqueThread;
if (lpCriticalSection->OwningThread != Thread) if (CriticalSection->OwningThread != Thread)
{ {
DbgPrint("Freeing critical section not owned\n"); DbgPrint("Freeing critical section not owned\n");
return; return;
} }
lpCriticalSection->RecursionCount--; CriticalSection->RecursionCount--;
if (lpCriticalSection->RecursionCount > 0) if (CriticalSection->RecursionCount > 0)
{ {
InterlockedDecrement(&lpCriticalSection->LockCount); InterlockedDecrement(&CriticalSection->LockCount);
return; return;
} }
lpCriticalSection->OwningThread = 0; CriticalSection->OwningThread = 0;
if (InterlockedIncrement(&lpCriticalSection->LockCount) >= 0) if (InterlockedIncrement(&CriticalSection->LockCount) >= 0)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = NtReleaseSemaphore(lpCriticalSection->LockSemaphore, 1, NULL); Status = NtReleaseSemaphore(CriticalSection->LockSemaphore, 1, NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DbgPrint("Failed to release semaphore (Status %x)\n", DbgPrint("Failed to release semaphore (Status %x)\n",
@ -125,37 +123,40 @@ RtlLeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
} }
#if 0 #if 0
lpCriticalSection->RecursionCount--; CriticalSection->RecursionCount--;
if (lpCriticalSection->RecursionCount == 0) if (CriticalSection->RecursionCount == 0)
{ {
lpCriticalSection->OwningThread = (HANDLE)-1; CriticalSection->OwningThread = (HANDLE)-1;
// if LockCount > 0 and RecursionCount == 0 there // if LockCount > 0 and RecursionCount == 0 there
// is a waiting thread // is a waiting thread
// ReleaseSemaphore will fire up a waiting thread // ReleaseSemaphore will fire up a waiting thread
if (InterlockedDecrement(&lpCriticalSection->LockCount) > 0) if (InterlockedDecrement(&CriticalSection->LockCount) > 0)
{ {
NtReleaseSemaphore( lpCriticalSection->LockSemaphore,1,NULL); NtReleaseSemaphore(CriticalSection->LockSemaphore,1,NULL);
} }
} }
else InterlockedDecrement( &lpCriticalSection->LockCount ); else
{
InterlockedDecrement(&CriticalSection->LockCount);
}
#endif #endif
} }
BOOLEAN STDCALL BOOLEAN STDCALL
RtlTryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection) RtlTryEnterCriticalSection(PCRITICAL_SECTION CriticalSection)
{ {
if (InterlockedCompareExchange((PVOID*)&lpCriticalSection->LockCount, if (InterlockedCompareExchange((PVOID*)&CriticalSection->LockCount,
(PVOID)1, (PVOID)0 ) == 0) (PVOID)1, (PVOID)0 ) == 0)
{ {
lpCriticalSection->OwningThread = CriticalSection->OwningThread =
(HANDLE) NtCurrentTeb()->Cid.UniqueThread; (HANDLE) NtCurrentTeb()->Cid.UniqueThread;
lpCriticalSection->RecursionCount++; CriticalSection->RecursionCount++;
return TRUE; return TRUE;
} }
if (lpCriticalSection->OwningThread == if (CriticalSection->OwningThread ==
(HANDLE)NtCurrentTeb()->Cid.UniqueThread) (HANDLE)NtCurrentTeb()->Cid.UniqueThread)
{ {
lpCriticalSection->RecursionCount++; CriticalSection->RecursionCount++;
return TRUE; return TRUE;
} }
return FALSE; return FALSE;