ExpAcquireResourceSharedLite

INT64 __stdcall ExpAcquireResourceSharedLite(PVOID LockAddress, INT8 a2){
  INT64 CurrentThread; 
  unsigned __int64 *v5; 
  int v6; 
  unsigned __int8 CurrentIrql; 
  KSPIN_LOCK_QUEUE *v8; 
  unsigned __int8 v9; 
  int v10; 
  _KSPIN_LOCK_QUEUE *volatile Next; 
  __int16 v13; 
  unsigned int v14; 
  CHAR *v15; 
  int v16; 
  int v17; 
  _KSPIN_LOCK_QUEUE *volatile v18; 
  _KSPIN_LOCK_QUEUE *volatile v19; 
  int v20; 
  __int64 v21; 
  _KSPIN_LOCK_QUEUE *volatile v22; 
  _ETHREAD *v23; 
  int v24; 
  unsigned int v25; 
  int v26; 
  void *v27; 
  int v28; 
  __int16 v29; 
  int v30; 
  int v31; 
  unsigned __int8 v32; 
  KSPIN_LOCK_QUEUE *v33; 
  CHAR *v34; 
  CHAR *v35; 
  _KSPIN_LOCK_QUEUE *volatile v36; 
  __int64 v37; 
  CHAR *v38; 
  _QWORD *v39; 
  _KSPIN_LOCK_QUEUE *volatile v40; 
  unsigned __int8 v41; 
  UINT64 FirstEntryInelligible; 
  UINT64 a6; 
  struct _KLOCK_QUEUE_HANDLE LockHandle; 
  KLOCK_QUEUE_HANDLE LockQueue; 
  __int128 Object; 
  __int128 v47; 
  __int128 v48; 
  struct _KPRCB *SystemArgument1; 
  Object = 0i64;
  v47 = 0i64;
  v48 = 0i64;
  CurrentThread = (INT64)KeGetCurrentThread();
  __incgsdword(0x868Cu);
  v5 = (unsigned __int64 *)((char *)LockAddress + 96);
  v6 = 0;
  LockHandle.LockQueue.Lock = (unsigned __int64 *volatile)((char *)LockAddress + 96);
  LockHandle.LockQueue.Next = 0i64;
  CurrentIrql = KeGetCurrentIrql();
  __writecr8(2ui64);
  *(_QWORD *)&LockHandle.OldIrql = CurrentIrql;
  v8 = (KSPIN_LOCK_QUEUE *)_InterlockedExchange64((volatile __int64 *)LockAddress + 12, (__int64)&LockHandle);
  if( v8 )
    KxWaitForLockOwnerShip(&LockHandle.LockQueue, v8);
  while( 1 )
  {
    if( !*((_DWORD *)LockAddress + 16) )
    {
      *((_WORD *)LockAddress + 12) = 1;
      *((_DWORD *)LockAddress + 16) = 1;
      v9 = 1;
      v10 = *((_DWORD *)LockAddress + 14) & 7;
      *((_QWORD *)LockAddress + 6) = CurrentThread;
      *((_DWORD *)LockAddress + 14) = v10 | 8;
      _m_prefetchw(&LockHandle);
      Next = LockHandle.LockQueue.Next;
      if( !LockHandle.LockQueue.Next )
      {
        if( (struct _KLOCK_QUEUE_HANDLE *)_InterlockedCompareExchange64(
                                             (volatile signed __int64 *)LockHandle.LockQueue.Lock,
                                             0i64,
                                             (signed __int64)&LockHandle) == &LockHandle )
        {
LABEL_6:
          __writecr8(LockHandle.OldIrql);
          __incgsdword(0x8694u);
          __incgsdword(0x8664u);
          return v9;
        }
        Next = KxWaitForLockChainValid(&LockHandle.LockQueue);
      }
      LockHandle.LockQueue.Next = 0i64;
      _InterlockedXor64((volatile signed __int64 *)&Next->Lock, 1ui64);
      goto LABEL_6;
    }
    v13 = *((_WORD *)LockAddress + 13) & 0x80;
    if( v13 )
    {
      if( *((_QWORD *)LockAddress + 6) == CurrentThread )
        break;
    }
    if( v13 )
    {
      v37 = *((_QWORD *)LockAddress + 2);
      if( v37 )
      {
        v38 = (CHAR *)(v37 + 16i64 * *(unsigned int *)(v37 + 8));
        v15 = (CHAR *)(v37 + 16);
        while( *(_QWORD *)v15 )
        {
          v15 += 16;
          if( v15 == v38 )
            goto LABEL_77;
        }
        *((_BYTE *)KeGetCurrentThread() + 649) = (__int64)(unsigned int)((_DWORD)v15 - *((_DWORD *)LockAddress + 4)) >> 4;
LABEL_11:
        if( *(_QWORD *)v15 != CurrentThread )
        {
          v16 = *((_DWORD *)LockAddress + 16);
          if( !v16 || *((char *)LockAddress + 26) >= 0 && !*((_DWORD *)LockAddress + 19) )
          {
            *((_WORD *)LockAddress + 12) = 1;
            *((_DWORD *)LockAddress + 16) = v16 + 1;
            v17 = *((_DWORD *)v15 + 2) & 7;
            *(_QWORD *)v15 = CurrentThread;
            *((_DWORD *)v15 + 2) = v17 | 8;
            _m_prefetchw(&LockHandle);
            v18 = LockHandle.LockQueue.Next;
            if( !LockHandle.LockQueue.Next )
            {
              if( (struct _KLOCK_QUEUE_HANDLE *)_InterlockedCompareExchange64(
                                                   (volatile signed __int64 *)LockHandle.LockQueue.Lock,
                                                   0i64,
                                                   (signed __int64)&LockHandle) == &LockHandle )
              {
LABEL_17:
                __writecr8(LockHandle.OldIrql);
                __incgsdword(0x8694u);
                __incgsdword(0x8664u);
                return 1;
              }
              v18 = KxWaitForLockChainValid(&LockHandle.LockQueue);
            }
            LockHandle.LockQueue.Next = 0i64;
            _InterlockedXor64((volatile signed __int64 *)&v18->Lock, 1ui64);
            goto LABEL_17;
          }
          if( !a2 )
          {
            KeReleaseInStackQueuedSpinLockFromDpcLevel(&LockHandle);
            __writecr8(LockHandle.OldIrql);
            __incgsdword(0x86A0u);
            return 0;
          }
          v20 = *((_DWORD *)v15 + 2);
          *(_QWORD *)v15 = CurrentThread;
          *((_DWORD *)v15 + 2) = v20 & 7 | 8;
          ++*((_DWORD *)LockAddress + 18);
          *((_QWORD *)&v48 + 1) = &v48;
          *(_QWORD *)&v48 = &v48;
          v21 = *((_QWORD *)LockAddress + 4);
          *((_QWORD *)&Object + 1) = 0i64;
          *((_QWORD *)&v47 + 1) = 393217i64;
          *(_QWORD *)&v47 = CurrentThread;
          if( v21 )
          {
            v39 = *(_QWORD **)(v21 + 8);
            if( *v39 != v21 )
              __fastfail(3u);
            *((_QWORD *)&Object + 1) = *(_QWORD *)(v21 + 8);
            *(_QWORD *)&Object = v21;
            *v39 = &Object;
            *(_QWORD *)(v21 + 8) = &Object;
          }
          else
          {
            *((_QWORD *)&Object + 1) = &Object;
            *(_QWORD *)&Object = &Object;
          }
          *((_QWORD *)LockAddress + 4) = &Object;
          _m_prefetchw(&LockHandle);
          v22 = LockHandle.LockQueue.Next;
          if( !LockHandle.LockQueue.Next )
          {
            if( (struct _KLOCK_QUEUE_HANDLE *)_InterlockedCompareExchange64(
                                                 (volatile signed __int64 *)LockHandle.LockQueue.Lock,
                                                 0i64,
                                                 (signed __int64)&LockHandle) == &LockHandle )
              goto LABEL_28;
            v22 = KxWaitForLockChainValid(&LockHandle.LockQueue);
          }
          LockHandle.LockQueue.Next = 0i64;
          _InterlockedXor64((volatile signed __int64 *)&v22->Lock, 1ui64);
LABEL_28:
          __writecr8(LockHandle.OldIrql);
          __incgsdword(0x869Cu);
          v23 = (_ETHREAD *)KeGetCurrentThread();
          v24 = 0;
          v25 = (*((_DWORD *)v23 + 324) >> 9) & 7;
          if( (*(_DWORD *)(*((_QWORD *)v23 + 68) + 1124i64) & 0x100000) != 0 )
          {
            v25 = 0;
          }
          else if( v25 >= 2 )
          {
            goto LABEL_30;
          }
          if( v23 == (_ETHREAD *)KeGetCurrentThread() && *((_DWORD *)v23 + 340) )
          {
LABEL_31:
            if( (*((_BYTE *)LockAddress + 26) & 4) == 0 )
              v24 = 4;
          }
          else
          {
LABEL_30:
            if( v25 > 1 )
              goto LABEL_31;
          }
          v26 = v24 | 2;
          if( (*((_WORD *)LockAddress + 13) & 2) != 0 )
            v26 = v24;
          v27 = (void *)HIBYTE(*((unsigned __int16 *)LockAddress + 13));
          v28 = v26 | 0xFF00;
          if( *((char *)v23 + 195) <= (int)v27 )
            v28 = v26;
          if( v28 )
            ExpApplyPriorityBoost((__int64)LockAddress, v28, (__int64)v23, v27);
          ExpWaitForResource((ERESOURCE *)LockAddress, &Object);
          if( (CurrentThread & 3) == 0 )
            v6 = *(unsigned __int8 *)(CurrentThread + 649);
          v29 = *((_WORD *)LockAddress + 13);
          memset(&LockQueue, 0, sizeof(LockQueue));
          if( (v29 & 8) == 0 )
          {
            v30 = 0;
            if( (v29 & 4) != 0
              && ((*(_DWORD *)(*(_QWORD *)(CurrentThread + 544) + 1124i64) & 0x100000) != 0
               || (*(_DWORD *)(CurrentThread + 1296) & 0xE00u) < 0x400) )
            {
              v30 = 4;
            }
            v31 = v30 | 2;
            if( (v29 & 2) == 0 )
              v31 = v30;
            if( v31 )
            {
              LockQueue.LockQueue.Lock = v5;
              LockQueue.LockQueue.Next = 0i64;
              v32 = KeGetCurrentIrql();
              __writecr8(2ui64);
              LockQueue.OldIrql = v32;
              v33 = (KSPIN_LOCK_QUEUE *)_InterlockedExchange64((volatile __int64 *)v5, (__int64)&LockQueue);
              if( v33 )
                KxWaitForLockOwnerShip(&LockQueue.LockQueue, v33);
              LODWORD(a6) = v6;
              LODWORD(FirstEntryInelligible) = 1;
              v34 = ExpFindCurrentThread(
                      (ERESOURCE *)LockAddress,
                      CurrentThread,
                      &LockQueue,
                      0i64,
                      FirstEntryInelligible,
                      a6);
              v35 = v34;
              if( (v31 & 4) != 0 )
              {
                if( (*((_DWORD *)v34 + 2) & 1) != 0 )
                {
                  v31 &= ~4u;
                }
                else
                {
                  PsBoostThreadIoEx(CurrentThread, 0, 0, 0i64);
                  *((_DWORD *)v35 + 2) |= 1u;
                }
              }
              if( (v31 & 2) != 0 )
              {
                if( (*((_DWORD *)v35 + 2) & 4) != 0 )
                {
                  v31 &= ~2u;
                }
                else
                {
                  if( _InterlockedIncrement((volatile signed __int32 *)(CurrentThread + 1364)) == 1
                    && *(_BYTE *)(CurrentThread + 793) )
                  {
                    v41 = KeGetCurrentIrql();
                    __writecr8(2ui64);
                    SystemArgument1 = KeGetCurrentPrcb();
                    if( (unsigned int)KiAbThreadInsertList(
                                         (_KTHREAD *)CurrentThread,
                                         (_SINGLE_LIST_ENTRY *)SystemArgument1 + 4335,
                                         (_SINGLE_LIST_ENTRY *)(CurrentThread + 808)) )
                      KiAbQueueAutoBoostDpc(SystemArgument1);
                    __writecr8(v41);
                  }
                  *((_DWORD *)v35 + 2) |= 4u;
                }
              }
              _m_prefetchw(&LockQueue);
              v36 = LockQueue.LockQueue.Next;
              if( !LockQueue.LockQueue.Next )
              {
                if( (KLOCK_QUEUE_HANDLE *)_InterlockedCompareExchange64(
                                             (volatile signed __int64 *)LockQueue.LockQueue.Lock,
                                             0i64,
                                             (signed __int64)&LockQueue) == &LockQueue )
                {
LABEL_58:
                  __writecr8(LockQueue.OldIrql);
                  if( v31 )
                  {
                    if( (v31 & 4) != 0 )
                      IoBoostThreadIoPriority((KSPIN_LOCK *)CurrentThread, 2, 0);
                    if( (v31 & 2) != 0 && *(_DWORD *)(CurrentThread + 1368) )
                      IoBoostThreadOutstandingIo(CurrentThread);
                  }
                  goto LABEL_64;
                }
                v36 = KxWaitForLockChainValid(&LockQueue.LockQueue);
              }
              LockQueue.LockQueue.Next = 0i64;
              _InterlockedXor64((volatile signed __int64 *)&v36->Lock, 1ui64);
              goto LABEL_58;
            }
          }
LABEL_64:
          __incgsdword(0x8694u);
          __incgsdword(0x8664u);
          return 1;
        }
        *((_DWORD *)v15 + 2) += 8;
        _m_prefetchw(&LockHandle);
        v40 = LockHandle.LockQueue.Next;
        if( !LockHandle.LockQueue.Next )
        {
          if( (struct _KLOCK_QUEUE_HANDLE *)_InterlockedCompareExchange64(
                                               (volatile signed __int64 *)LockHandle.LockQueue.Lock,
                                               0i64,
                                               (signed __int64)&LockHandle) == &LockHandle )
          {
LABEL_75:
            __writecr8(LockHandle.OldIrql);
            __incgsdword(0x8698u);
            __incgsdword(0x8664u);
            return 1;
          }
          v40 = KxWaitForLockChainValid(&LockHandle.LockQueue);
        }
        LockHandle.LockQueue.Next = 0i64;
        _InterlockedXor64((volatile signed __int64 *)&v40->Lock, 1ui64);
        goto LABEL_75;
      }
LABEL_77:
      ExpExpandResourceOwnerTable((ERESOURCE *)LockAddress, &LockHandle);
    }
    else
    {
      LODWORD(a6) = ExpGetThreadResourceHint(CurrentThread);
      LODWORD(FirstEntryInelligible) = *((_DWORD *)LockAddress + 19) != 0;
      v15 = ExpFindCurrentThread((ERESOURCE *)LockAddress, CurrentThread, &LockHandle, v14, FirstEntryInelligible, a6);
      if( v15 )
        goto LABEL_11;
    }
  }
  *((_DWORD *)LockAddress + 14) += 8;
  _m_prefetchw(&LockHandle);
  v19 = LockHandle.LockQueue.Next;
  if( !LockHandle.LockQueue.Next )
  {
    if( (struct _KLOCK_QUEUE_HANDLE *)_InterlockedCompareExchange64(
                                         (volatile signed __int64 *)LockHandle.LockQueue.Lock,
                                         0i64,
                                         (signed __int64)&LockHandle) == &LockHandle )
      goto LABEL_22;
    v19 = KxWaitForLockChainValid(&LockHandle.LockQueue);
  }
  LockHandle.LockQueue.Next = 0i64;
  _InterlockedXor64((volatile signed __int64 *)&v19->Lock, 1ui64);
LABEL_22:
  __writecr8(LockHandle.OldIrql);
  __incgsdword(0x8690u);
  __incgsdword(0x8664u);
  return 1;
}

Referenced by: