KeSetActualBasePriorityThread

NTSTATUS __stdcall KeSetActualBasePriorityThread(_ETHREAD *Thread, INT64 NewBase){
  UINT8 CurrentIrql; 
  struct _KPRCB *CurrentPrcb; 
  _ETHREAD *CurrentThread; 
  NTSTATUS BasePriority; 
  NTSTATUS v7; 
  _KPRCB *v8; 
  char PriorityDecrement; 
  unsigned __int64 CycleTime; 
  unsigned __int64 v11; 
  unsigned int v12; 
  char v13; 
  int v14; 
  int Priority; 
  _KPRCB *v16; 
  _ETHREAD *NextThread; 
  bool v18; 
  _ETHREAD *v19; 
  _KPRCB *v20; 
  _ETHREAD *v21; 
  char v22; 
  _KPRCB *v23; 
  _KPRIQUEUE *Queue; 
  struct _KPRCB *v26; 
  int *v27; 
  _SINGLE_LIST_ENTRY *p_IoSelfBoostsEntry; 
  _SINGLE_LIST_ENTRY *p_AbSelfIoBoostsList; 
  UINT64 Number; 
  UINT8 IsThreadRankNonZero; 
  char v32; 
  INT32 *v33; 
  INT64 v34; 
  bool v35; 
  _ETHREAD *v36; 
  _KPRCB *v37; 
  _ETHREAD *v38; 
  UINT8 v39; 
  char v40; 
  _DWORD *SchedulerAssist; 
  _BYTE *v42; 
  INT64 v43; 
  bool v44; 
  int v45; 
  int v46; 
  _DWORD *v47; 
  _KPRCB *v48; 
  __int64 v49; 
  UINT8 v50; 
  _KSHARED_READY_QUEUE *ControlReadyQueue; 
  _SINGLE_LIST_ENTRY a2; 
  _ETHREAD **p_NextThread; 
  NTSTATUS v54; 
  int DynamicPriority; 
  UINT64 SpinCount; 
  _KPRCB *ControlPrcb; 

  DynamicPriority = NewBase;
  if( Thread->Tcb.Process == (_EPROCESS *)&KiInitialProcess )
    return 1;
  a2.Next = 0i64;
  CurrentIrql = KeGetCurrentIrql();
  v50 = CurrentIrql;
  __writecr8(2ui64);
  CurrentPrcb = KeGetCurrentPrcb();
  LODWORD(SpinCount) = 0;
  CurrentThread = CurrentPrcb->CurrentThread;
  while( _interlockedbittestandset64((volatile signed __int32 *)&Thread->Tcb.ThreadLock, 0i64) )
  {
    do
      KeYieldProcessorEx(&SpinCount);
    while( Thread->Tcb.ThreadLock );
    SchedulerAssist = CurrentPrcb->SchedulerAssist;
    if( SchedulerAssist && CurrentPrcb->NestingLevel <= 1u )
      ++SchedulerAssist[6];
  }
  BasePriority = Thread->Tcb.BasePriority;
  Thread->Tcb.Saturation = 0;
  v7 = BasePriority;
  v8 = KeGetCurrentPrcb();
  v54 = BasePriority;
  if( (char)DynamicPriority < (char)BasePriority )
  {
    if( Thread->Tcb.AbOwnedEntryCount )
    {
      p_IoSelfBoostsEntry = &Thread->Tcb.IoSelfBoostsEntry;
      if( Thread->Tcb.IoSelfBoostsEntry.Next == (_SINGLE_LIST_ENTRY *)1 )
      {
        p_AbSelfIoBoostsList = &v8->AbSelfIoBoostsList;
        if( v8 != (_KPRCB *)-34672i64 )
        {
          p_IoSelfBoostsEntry->Next = p_AbSelfIoBoostsList->Next;
          p_AbSelfIoBoostsList->Next = p_IoSelfBoostsEntry;
          _InterlockedIncrement16(&Thread->Tcb.KeReferenceCount);
          KiAbQueueAutoBoostDpc(v8);
        }
      }
    }
  }
  Thread->Tcb.BasePriority = DynamicPriority;
  PriorityDecrement = Thread->Tcb.PriorityDecrement;
  if( PriorityDecrement )
  {
    if( (PriorityDecrement & 0xF) != 0 )
      Thread->Tcb.ForegroundLossTime = KUSER_SHARED_DATA.TickCount.LowPart;
    Thread->Tcb.PriorityDecrement = 0;
  }
  if( DynamicPriority != Thread->Tcb.Priority )
  {
    if( Thread != CurrentThread || CurrentPrcb->NestingLevel )
    {
      CycleTime = Thread->Tcb.CycleTime;
    }
    else
    {
      _disable();
      CycleTime = KiUpdateTotalCyclesCurrentThread(CurrentPrcb, &Thread->Tcb, 0i64);
      _enable();
    }
    v11 = CycleTime + KiCyclesPerClockQuantum * (unsigned int)Thread->Tcb.SchedulerApc.SpareByte1;
    if( (*(&Thread->Tcb.MiscFlags + 1) & 0x20) != 0 )
      _interlockedbittestandreset((volatile signed __int32 *)&Thread->Tcb.116 + 1, 5u);
    Thread->Tcb.QuantumTarget = v11;
    ControlPrcb = 0i64;
    ControlReadyQueue = 0i64;
    v12 = KiComputePriorityFloor(&Thread->Tcb, DynamicPriority);
    if( Thread->Tcb.Priority != v12 )
    {
      KiAcquireThreadStateLock(Thread, &ControlPrcb, &ControlReadyQueue);
      v14 = 0;
      Priority = Thread->Tcb.Priority;
      switch( v13 )
      {
        case 2:
          v16 = ControlPrcb;
          NextThread = ControlPrcb->NextThread;
          p_NextThread = &ControlPrcb->NextThread;
          KiUpdateThreadPriority(ControlPrcb, &Thread->Tcb, v12, NextThread == 0i64);
          v18 = (int)v12 <= Priority;
          if( (int)v12 < Priority )
          {
            if( !NextThread )
            {
              v16 = ControlPrcb;
              if( Thread->Tcb.WaitBlockFill6[68] != 2 )
              {
                v7 = v54;
                if( ControlPrcb->ReadySummary >> (v12 + 1) )
                  Thread->Tcb.WaitRegister.Flags |= 0x10u;
                goto LABEL_19;
              }
              v19 = (_ETHREAD *)KiSelectReadyThreadEx(ControlPrcb, &Thread->Tcb, 0);
              v21 = v19;
              if( v19 )
              {
                if( (v19->Tcb.gap0[2] & 4) != 0 )
                {
                  IsThreadRankNonZero = KiIsThreadRankNonZero(&v19->Tcb, v16, v20);
                  v32 = 1;
                  if( !IsThreadRankNonZero )
                    v32 = v21->Tcb.Priority;
                }
                else
                {
                  v32 = v19->Tcb.Priority;
                }
                *v16->PriorityState = v32;
                v33 = (INT32 *)v16->SchedulerAssist;
                if( v33 )
                {
                  if( v21 == v16->IdleThread )
                    v34 = (unsigned int)KiVpThreadSystemWorkPriority;
                  else
                    v34 = (unsigned int)v32;
                  KiSetSchedulerAssistPriority(v33, v34, 0);
                  v33 = (INT32 *)v16->SchedulerAssist;
                }
                v35 = v21 == v16->IdleThread;
                *p_NextThread = v21;
                if( v33 )
                  *((_BYTE *)v33 + 16) = v35;
                if( v21->Tcb.WaitBlockFill6[68] == 1 )
                  v21->Tcb.ReadyTime = v21->Tcb.ReadyTime
                                     - v21->Tcb.WaitBlock[2].SpareLong
                                     + KUSER_SHARED_DATA.TickCount.LowPart;
                v16 = ControlPrcb;
                v7 = v54;
                v21->Tcb.WaitBlockFill6[68] = 3;
                v22 = 1;
                goto LABEL_20;
              }
              goto LABEL_18;
            }
            v18 = (int)v12 <= Priority;
          }
          if( v18 || NextThread )
          {
LABEL_18:
            v7 = v54;
LABEL_19:
            v22 = 0;
LABEL_20:
            KiUpdateSharedReadyQueueAffinityThread(0i64, &Thread->Tcb);
            KiReleaseThreadStateLock(v23, (_KSHARED_READY_QUEUE *)v16);
            if( v22 )
            {
              Number = ControlPrcb->Number;
              if( KeGetPcr()->Prcb.Number != (_DWORD)Number )
                KiSendSoftwareInterrupt(Number, 2u);
            }
            if( v14 > 0 )
            {
              v26 = KeGetCurrentPrcb();
              if( (KiVelocityFlags & 2) != 0 )
              {
                v27 = (int *)ControlPrcb->SchedulerAssist;
                if( v27 )
                {
                  if( v26->SchedulerAssist )
                  {
                    if( v26 != ControlPrcb && v14 >= 8 )
                    {
                      v45 = *v27;
                      v46 = *v27 & 0x40000;
                      if( (v45 & 0x100000) != 0 || v46 && (unsigned __int8)v45 < v14 )
                      {
                        v35 = HvlpVirtualProcessorsIdentityMapped == 0;
                        v47 = v26->SchedulerAssist;
                        v48 = ControlPrcb;
                        v47[3] = 2;
                        v49 = v48->Number;
                        if( v35 )
                          LODWORD(v49) = (unsigned __int8)HvlpVirtualProcessorMapping[2 * (unsigned int)v49 + 1] | ((unsigned __int8)HvlpVirtualProcessorMapping[2 * v49] << 6);
                        v47[2] = v49;
                        __writemsr(0x400000C2u, (unsigned int)v49);
                      }
                    }
                  }
                }
              }
            }
            CurrentIrql = v50;
            goto LABEL_23;
          }
          v16 = ControlPrcb;
          v7 = v54;
          if( Thread->Tcb.WaitBlockFill6[68] != 2 )
            goto LABEL_19;
          break;
        case 1:
          v16 = ControlPrcb;
          KiRemoveThreadFromAnyReadyQueue(ControlPrcb, ControlReadyQueue, (__int64)Thread, (unsigned int)Priority);
          KiUpdateThreadPriority(0i64, &Thread->Tcb, v12, 0);
          KiPrepareReadyThreadForRescheduling(&Thread->Tcb, v12, &a2);
          goto LABEL_19;
        case 3:
          v16 = ControlPrcb;
          KiUpdateThreadPriority(ControlPrcb, &Thread->Tcb, v12, 1u);
          if( (int)v12 < Priority )
          {
            v36 = (_ETHREAD *)KiSelectReadyThreadEx(v16, &Thread->Tcb, 0);
            v38 = v36;
            if( v36 )
            {
              if( (v36->Tcb.gap0[2] & 4) != 0 )
              {
                v39 = KiIsThreadRankNonZero(&v36->Tcb, v16, v37);
                v40 = 1;
                if( !v39 )
                  v40 = v38->Tcb.Priority;
              }
              else
              {
                v40 = v36->Tcb.Priority;
              }
              *v16->PriorityState = v40;
              v42 = v16->SchedulerAssist;
              if( v42 )
              {
                v43 = (unsigned int)KiVpThreadSystemWorkPriority;
                if( v38 != v16->IdleThread )
                  v43 = (unsigned int)v40;
                KiSetSchedulerAssistPriority((INT32 *)v16->SchedulerAssist, v43, 0);
                v42 = v16->SchedulerAssist;
              }
              v44 = v38 == v16->IdleThread;
              v16->NextThread = v38;
              if( v42 )
                v42[16] = v44;
              if( v38->Tcb.WaitBlockFill6[68] == 1 )
                v38->Tcb.ReadyTime = v38->Tcb.ReadyTime
                                   - v38->Tcb.WaitBlock[2].SpareLong
                                   + KUSER_SHARED_DATA.TickCount.LowPart;
              v38->Tcb.WaitBlockFill6[68] = 3;
              KiInsertDeferredReadyList((INT64)&a2, (INT64)Thread);
              v16 = ControlPrcb;
            }
            goto LABEL_19;
          }
          break;
        default:
          KiUpdateThreadPriority(0i64, &Thread->Tcb, v12, 0);
          v16 = ControlPrcb;
          goto LABEL_19;
      }
      v14 = v12;
      goto LABEL_19;
    }
  }
LABEL_23:
  Queue = (_KPRIQUEUE *)Thread->Tcb.Queue;
  if( Queue && (*(_BYTE *)Queue & 0x7F) == 21 )
    KiPriQueueThreadPriorityChanged(Queue, &Thread->Tcb);
  else
    Thread->Tcb.ThreadLock = 0i64;
  KiProcessDeferredReadyList(CurrentPrcb, &a2, CurrentIrql);
  return v7;
}

Referenced by: