reactos/lib/rtl/resource.c

/*
 * COPYRIGHT:         See COPYING in the top level directory
 * PROJECT:           ReactOS system libraries
 * FILE:              lib/rtl/resource.c
 * PURPOSE:           Resource (multiple-reader-single-writer lock) functions
 * PROGRAMMER:        Partially takem from Wine:
 *                    Copyright 1996-1998 Marcus Meissner
 *                              1999 Alex Korobka
 */

/* INCLUDES *****************************************************************/

#include <rtl.h>

#define NDEBUG
#include <debug.h>

/* FUNCTIONS ***************************************************************/

/*
 * @implemented
 */
VOID NTAPI
RtlInitializeResource(PRTL_RESOURCE Resource)
{
   NTSTATUS Status;

   Status = RtlInitializeCriticalSection(&Resource->Lock);
   if (!NT_SUCCESS(Status))
     {
	RtlRaiseStatus(Status);
     }

   Status = NtCreateSemaphore(&Resource->SharedSemaphore,
			      SEMAPHORE_ALL_ACCESS,
			      NULL,
			      0,
			      65535);
   if (!NT_SUCCESS(Status))
     {
	RtlRaiseStatus(Status);
     }
   Resource->SharedWaiters = 0;

   Status = NtCreateSemaphore(&Resource->ExclusiveSemaphore,
			      SEMAPHORE_ALL_ACCESS,
			      NULL,
			      0,
			      65535);
   if (!NT_SUCCESS(Status))
     {
	RtlRaiseStatus(Status);
     }
   Resource->ExclusiveWaiters = 0;

   Resource->NumberActive = 0;
   Resource->OwningThread = NULL;
   Resource->TimeoutBoost = 0; /* no info on this one, default value is 0 */
}


/*
 * @implemented
 */
VOID NTAPI
RtlDeleteResource(PRTL_RESOURCE Resource)
{
   RtlDeleteCriticalSection(&Resource->Lock);
   NtClose(Resource->ExclusiveSemaphore);
   NtClose(Resource->SharedSemaphore);
   Resource->OwningThread = NULL;
   Resource->ExclusiveWaiters = 0;
   Resource->SharedWaiters = 0;
   Resource->NumberActive = 0;
}


/*
 * @implemented
 */
BOOLEAN NTAPI
RtlAcquireResourceExclusive(PRTL_RESOURCE Resource,
			    BOOLEAN Wait)
{
   NTSTATUS Status;
   BOOLEAN retVal = FALSE;

start:
    RtlEnterCriticalSection(&Resource->Lock);
    if (Resource->NumberActive == 0) /* lock is free */
      {
	Resource->NumberActive = -1;
	retVal = TRUE;
      }
    else if (Resource->NumberActive < 0) /* exclusive lock in progress */
      {
	if (Resource->OwningThread == NtCurrentTeb()->ClientId.UniqueThread)
	  {
	     retVal = TRUE;
	     Resource->NumberActive--;
	     goto done;
	  }
wait:
	if (Wait == TRUE)
	  {
	     Resource->ExclusiveWaiters++;

	     RtlLeaveCriticalSection(&Resource->Lock);
	     Status = NtWaitForSingleObject(Resource->ExclusiveSemaphore,
					    FALSE,
					    NULL);
	     if (!NT_SUCCESS(Status))
	       goto done;
	     goto start; /* restart the acquisition to avoid deadlocks */
	  }
     }
   else  /* one or more shared locks are in progress */
     {
	if (Wait == TRUE)
	  goto wait;
     }
   if (retVal == TRUE)
     Resource->OwningThread = NtCurrentTeb()->ClientId.UniqueThread;
done:
    RtlLeaveCriticalSection(&Resource->Lock);
    return retVal;
}


/*
 * @implemented
 */
BOOLEAN NTAPI
RtlAcquireResourceShared(PRTL_RESOURCE Resource,
			 BOOLEAN Wait)
{
   NTSTATUS Status = STATUS_UNSUCCESSFUL;
   BOOLEAN retVal = FALSE;

start:
   RtlEnterCriticalSection(&Resource->Lock);
   if (Resource->NumberActive < 0)
     {
	if (Resource->OwningThread == NtCurrentTeb()->ClientId.UniqueThread)
	  {
	     Resource->NumberActive--;
	     retVal = TRUE;
	     goto done;
	  }

	if (Wait == TRUE)
	  {
	     Resource->SharedWaiters++;
	     RtlLeaveCriticalSection(&Resource->Lock);
	     Status = NtWaitForSingleObject(Resource->SharedSemaphore,
					    FALSE,
					    NULL);
	     if (!NT_SUCCESS(Status))
	       goto done;
	     goto start;
	  }
     }
   else
     {
	if (Status != STATUS_WAIT_0) /* otherwise RtlReleaseResource() has already done it */
	  Resource->NumberActive++;
	retVal = TRUE;
     }
done:
   RtlLeaveCriticalSection(&Resource->Lock);
   return retVal;
}


/*
 * @implemented
 */
VOID NTAPI
RtlConvertExclusiveToShared(PRTL_RESOURCE Resource)
{
   RtlEnterCriticalSection(&Resource->Lock);

   if (Resource->NumberActive == -1)
     {
	Resource->OwningThread = NULL;

	if (Resource->SharedWaiters > 0)
	  {
	     ULONG n;
	     /* prevent new writers from joining until
	      * all queued readers have done their thing */
	     n = Resource->SharedWaiters;
	     Resource->NumberActive = Resource->SharedWaiters + 1;
	     Resource->SharedWaiters = 0;
	     NtReleaseSemaphore(Resource->SharedSemaphore,
				n,
				NULL);
	  }
	else
	  {
	     Resource->NumberActive = 1;
	  }
     }

   RtlLeaveCriticalSection(&Resource->Lock);
}


/*
 * @implemented
 */
VOID NTAPI
RtlConvertSharedToExclusive(PRTL_RESOURCE Resource)
{
   NTSTATUS Status;

   RtlEnterCriticalSection(&Resource->Lock);

   if (Resource->NumberActive == 1)
     {
	Resource->OwningThread = NtCurrentTeb()->ClientId.UniqueThread;
	Resource->NumberActive = -1;
     }
   else
     {
	Resource->ExclusiveWaiters++;

	RtlLeaveCriticalSection(&Resource->Lock);
	Status = NtWaitForSingleObject(Resource->ExclusiveSemaphore,
				       FALSE,
				       NULL);
	if (!NT_SUCCESS(Status))
	   return;

	RtlEnterCriticalSection(&Resource->Lock);
	Resource->OwningThread = NtCurrentTeb()->ClientId.UniqueThread;
	Resource->NumberActive = -1;
     }
   RtlLeaveCriticalSection(&Resource->Lock);
}


/*
 * @implemented
 */
VOID NTAPI
RtlReleaseResource(PRTL_RESOURCE Resource)
{
   RtlEnterCriticalSection(&Resource->Lock);

   if (Resource->NumberActive > 0) /* have one or more readers */
     {
	Resource->NumberActive--;
	if (Resource->NumberActive == 0)
	  {
	     if (Resource->ExclusiveWaiters > 0)
	       {
wake_exclusive:
		  Resource->ExclusiveWaiters--;
		  NtReleaseSemaphore(Resource->ExclusiveSemaphore,
				     1,
				     NULL);
	       }
	  }
     }
   else if (Resource->NumberActive < 0) /* have a writer, possibly recursive */
     {
	Resource->NumberActive++;
	if (Resource->NumberActive == 0)
	  {
	     Resource->OwningThread = 0;
	     if (Resource->ExclusiveWaiters > 0)
	       {
		  goto wake_exclusive;
	       }
	     else
	       {
		  if (Resource->SharedWaiters > 0)
		    {
		       ULONG n;
		       /* prevent new writers from joining until
		        * all queued readers have done their thing */
		       n = Resource->SharedWaiters;
		       Resource->NumberActive = Resource->SharedWaiters;
		       Resource->SharedWaiters = 0;
		       NtReleaseSemaphore(Resource->SharedSemaphore,
					  n,
					  NULL);
		    }
	       }
	  }
     }
   RtlLeaveCriticalSection(&Resource->Lock);
}


/*
 * @implemented
 */
VOID NTAPI
RtlDumpResource(PRTL_RESOURCE Resource)
{
   DbgPrint("RtlDumpResource(%p):\n\tactive count = %i\n\twaiting readers = %i\n\twaiting writers = %i\n",
	    Resource,
	    Resource->NumberActive,
	    Resource->SharedWaiters,
	    Resource->ExclusiveWaiters);
   if (Resource->NumberActive != 0)
     {
	DbgPrint("\towner thread = %08x\n",
		 Resource->OwningThread);
     }
}

/* EOF */