KeDelayExecutionThread

VOID __fastcall KeDelayExecutionThread(CHAR WaitMode, UINT8 Alertable, _LARGE_INTEGER *Interval){
  _ETHREAD *CurrentThread; 
  struct _KPRCB *CurrentPrcb; 
  UINT8 v8; 
  UINT64 v9; 
  _KDUE_TIME_TYPE v10; 
  int v11; 
  _ETHREAD *v12; 
  int v13; 
  _ETHREAD *v14; 
  unsigned __int8 v15; 
  struct _KPRCB *v16; 
  struct _KPRCB *v17; 
  struct _KPRCB *v18; 
  _ETHREAD *NextThread; 
  UINT64 CycleTime; 
  unsigned __int64 v21; 
  unsigned int v22; 
  _KPRCB *v23; 
  _SINGLE_LIST_ENTRY *p_AbPropagateBoostsList; 
  bool v25; 
  INT64 v26; 
  _KPRCB *v27; 
  char Priority; 
  _DWORD *v29; 
  unsigned __int8 CurrentIrql; 
  UINT8 IsThreadRankNonZero; 
  _DWORD *SchedulerAssist; 
  _SINGLE_LIST_ENTRY *p_PropagateBoostsEntry; 
  INT64 v34; 
  _KDUE_TIME_TYPE *TimeoutType; 
  INT64 v36; 
  INT64 v37; 
  int v38; 
  __int64 DueTime[2]; 
  UINT8 v40; 
  _KDUE_TIME_TYPE v41; 

  CurrentThread = (_ETHREAD *)KeGetCurrentThread();
  DueTime[0] = 0i64;
  v41 = DueTimeNone;
  if( Interval->QuadPart || !WaitMode || Alertable || (CurrentThread->Tcb.ApcState.UserApcPendingAll & 2) != 0 )
  {
    v8 = KiCheckWaitNext(&CurrentThread->Tcb, Interval, 1u, (UINT64 *)DueTime, &v41);
    v9 = DueTime[0];
    v10 = v41;
    v40 = v8;
    while( 1 )
    {
      KiBeginThreadWait(CurrentThread, WaitMode, DelayExecution, Alertable);
      v38 = v11;
      if( v11 )
        break;
      if( (unsigned int)KiCheckDueTimeExpired(&CurrentThread->Tcb, v10, v9) )
      {
        KiFastExitThreadWait(KeGetCurrentPrcb(), &CurrentThread->Tcb, v40);
        if( !Interval->QuadPart )
          KeYieldExecution(0i64);
        return;
      }
      CurrentThread->Tcb.WaitBlock[0].Object = (void *)-1i64;
      CurrentThread->Tcb.WaitBlockFill4[17] = 5;
      CurrentThread->Tcb.WaitBlockCount = 1;
      KiCommitThreadWait(v12, CurrentThread->Tcb.WaitBlock, v10, v9);
      if( v13 != 256 )
        return;
      v40 = 0;
      CurrentIrql = KeGetCurrentIrql();
      __writecr8(2ui64);
      CurrentThread->Tcb.WaitIrql = CurrentIrql;
    }
  }
  else
  {
    CurrentPrcb = KeGetCurrentPrcb();
    if( CurrentPrcb->ReadySummary || CurrentPrcb->SharedReadyQueue->ReadySummary )
    {
      v14 = (_ETHREAD *)KeGetCurrentThread();
      v15 = KeGetCurrentIrql();
      __writecr8(2ui64);
      v16 = KeGetCurrentPrcb();
      if( v16->ReadySummary || v16->SharedReadyQueue->ReadySummary )
      {
        KiAbProcessContextSwitch(&v14->Tcb, 0i64);
        v17 = KeGetCurrentPrcb();
        LODWORD(v37) = 0;
        while( _interlockedbittestandset64((volatile signed __int32 *)&v14->Tcb.ThreadLock, 0i64) )
        {
          do
            KeYieldProcessorEx((UINT64 *)&v37);
          while( v14->Tcb.ThreadLock );
          SchedulerAssist = v17->SchedulerAssist;
          if( SchedulerAssist && v17->NestingLevel <= 1u )
            ++SchedulerAssist[6];
        }
        v18 = KeGetCurrentPrcb();
        HIDWORD(v37) = 0;
        while( _interlockedbittestandset64((volatile signed __int32 *)&v16->PrcbLock, 0i64) )
        {
          do
            KeYieldProcessorEx((UINT64 *)((char *)&v37 + 4));
          while( v16->PrcbLock );
          v29 = v18->SchedulerAssist;
          if( v29 && v18->NestingLevel <= 1u )
            ++v29[6];
        }
        NextThread = v16->NextThread;
        if( NextThread || (NextThread = (_ETHREAD *)KiSelectReadyThreadEx(v16, 0i64, 1u)) != 0i64 )
        {
          if( v16->NestingLevel )
          {
            CycleTime = v14->Tcb.CycleTime;
          }
          else
          {
            _disable();
            CycleTime = KiUpdateTotalCyclesCurrentThread(v16, &v14->Tcb, 0i64);
            _enable();
          }
          v21 = CycleTime + KiCyclesPerClockQuantum * (unsigned int)v14->Tcb.SchedulerApc.SpareByte1;
          if( (*(&v14->Tcb.MiscFlags + 1) & 0x20) != 0 )
            _interlockedbittestandreset((volatile signed __int32 *)&v14->Tcb.116 + 1, 5u);
          v14->Tcb.QuantumTarget = v21;
          v22 = KiComputeNewPriority(&v14->Tcb, 1);
          if( !(unsigned __int8)KiUpdateVPBackingThreadPriority(v14) )
          {
            v23 = KeGetCurrentPrcb();
            if( (char)v22 > v14->Tcb.Priority )
            {
              if( v14->Tcb.AbWaitEntryCount )
              {
                p_PropagateBoostsEntry = &v14->Tcb.PropagateBoostsEntry;
                if( v14->Tcb.PropagateBoostsEntry.Next == (_SINGLE_LIST_ENTRY *)1 )
                {
                  p_AbPropagateBoostsList = &v23->AbPropagateBoostsList;
                  if( v23 != (_KPRCB *)-34680i64 )
                  {
                    p_PropagateBoostsEntry->Next = p_AbPropagateBoostsList->Next;
                    p_AbPropagateBoostsList->Next = p_PropagateBoostsEntry;
                    _InterlockedIncrement16(&v14->Tcb.KeReferenceCount);
                    KiAbQueueAutoBoostDpc(v23);
                  }
                }
              }
            }
            v25 = (*(&v14->Tcb.MiscFlags + 1) & 0x400000) == 0;
            v14->Tcb.Priority = v22;
            if( !v25 )
              KiSetSchedulerAssistPriority((INT32 *)v14->Tcb.SchedulerAssist, v22, 1);
          }
          KiReleaseThreadLockSafe((INT64)v14);
          v16->NextThread = 0i64;
          _disable();
          KiEndThreadCycleAccumulation((INT64)v16, (INT64)v14, 0i64, v26, (INT64)TimeoutType, v36, v37);
          _enable();
          if( (NextThread->Tcb.gap0[2] & 4) == 0
            || (IsThreadRankNonZero = KiIsThreadRankNonZero(&NextThread->Tcb, v16, v27),
                Priority = 1,
                !IsThreadRankNonZero) )
          {
            Priority = NextThread->Tcb.Priority;
          }
          *v16->PriorityState = Priority;
          if( v16->SchedulerAssist )
          {
            v34 = (unsigned int)KiVpThreadSystemWorkPriority;
            if( NextThread != v16->IdleThread )
              v34 = (unsigned int)Priority;
            KiSetSchedulerAssistPriority((INT32 *)v16->SchedulerAssist, v34, 0);
          }
          v16->CurrentThread = NextThread;
          if( NextThread->Tcb.WaitBlockFill6[68] == 1 )
            NextThread->Tcb.ReadyTime = NextThread->Tcb.ReadyTime
                                      - NextThread->Tcb.WaitBlock[2].SpareLong
                                      + KUSER_SHARED_DATA.TickCount.LowPart;
          NextThread->Tcb.WaitBlockFill6[68] = 2;
          v14->Tcb.WaitReason = 33;
          v14->Tcb.WaitIrql = v15;
          KiQueueReadyThread(v16, &v14->Tcb);
          KiSwapContext();
        }
        else
        {
          _InterlockedAnd64((volatile signed __int64 *)&v16->PrcbLock, 0i64);
          KiReleaseThreadLockSafe((INT64)v14);
        }
      }
      __writecr8(v15);
    }
  }
}

Referenced by: