reactos/drivers/net/tcpip/recmutex/recmutex.c

   1 #include <ntddk.h>
   2 #include "recmutex.h"
   3
   4 VOID RecursiveMutexInit( PRECURSIVE_MUTEX RecMutex ) {
   5     RtlZeroMemory( RecMutex, sizeof(*RecMutex) );
   6     KeInitializeSpinLock( &RecMutex->SpinLock );
   7     ExInitializeFastMutex( &RecMutex->Mutex );
   8     KeInitializeEvent( &RecMutex->StateLockedEvent,
   9                        NotificationEvent, FALSE );
  10 }
  11
  12 /* NOTE: When we leave, the FAST_MUTEX must have been released.  The result
  13  * is that we always exit in the same irql as entering */
  14 UINT RecursiveMutexEnter( PRECURSIVE_MUTEX RecMutex, BOOL ToWrite ) {
  15     NTSTATUS Status = STATUS_SUCCESS;
  16     PVOID CurrentThread = KeGetCurrentThread();
  17
  18     /* Wait for the previous user to unlock the RecMutex state.  There might be
  19      * multiple waiters waiting to change the state.  We need to check each
  20      * time we get the event whether somebody still has the state locked */
  21
  22     if( !RecMutex ) return FALSE;
  23
  24     if( CurrentThread == RecMutex->CurrentThread ||
  25         (!ToWrite && !RecMutex->Writer) ) {
  26         RecMutex->LockCount++;
  27         return TRUE;
  28     }
  29
  30     if( KeGetCurrentIrql() == PASSIVE_LEVEL ) {
  31         ExAcquireFastMutex( &RecMutex->Mutex );
  32         RecMutex->OldIrql = PASSIVE_LEVEL;
  33         while( RecMutex->Locked ) {
  34             ExReleaseFastMutex( &RecMutex->Mutex );
  35             Status = KeWaitForSingleObject( &RecMutex->StateLockedEvent,
  36                                             UserRequest,
  37                                             KernelMode,
  38                                             FALSE,
  39                                             NULL );
  40             ExAcquireFastMutex( &RecMutex->Mutex );
  41         }
  42         RecMutex->Locked = TRUE;
  43         RecMutex->Writer = ToWrite;
  44         RecMutex->CurrentThread = CurrentThread;
  45         RecMutex->LockCount++;
  46         ExReleaseFastMutex( &RecMutex->Mutex );
  47     } else {
  48         KeAcquireSpinLock( &RecMutex->SpinLock, &RecMutex->OldIrql );
  49         RecMutex->Locked = TRUE;
  50         RecMutex->Writer = ToWrite;
  51         RecMutex->CurrentThread = CurrentThread;
  52         RecMutex->LockCount++;
  53     }
  54
  55     return TRUE;
  56 }
  57
  58 VOID RecursiveMutexLeave( PRECURSIVE_MUTEX RecMutex ) {
  59     if( RecMutex->LockCount == 0 ) {
  60         return;
  61     } else
  62         RecMutex->LockCount--;
  63
  64     if( !RecMutex->LockCount ) {
  65         RecMutex->CurrentThread = NULL;
  66         if( RecMutex->OldIrql == PASSIVE_LEVEL ) {
  67             ExAcquireFastMutex( &RecMutex->Mutex );
  68             RecMutex->Locked = FALSE;
  69             RecMutex->Writer = FALSE;
  70             ExReleaseFastMutex( &RecMutex->Mutex );
  71         } else {
  72             RecMutex->Locked = FALSE;
  73             RecMutex->Writer = FALSE;
  74             KeReleaseSpinLock( &RecMutex->SpinLock, RecMutex->OldIrql );
  75         }
  76
  77         RecMutex->OldIrql = PASSIVE_LEVEL;
  78         KePulseEvent( &RecMutex->StateLockedEvent, IO_NETWORK_INCREMENT,
  79                       FALSE );
  80     }
  81 }
  82