KeInsertSchedulingGroup

VOID __stdcall KeInsertSchedulingGroup(
        _KSCHEDULING_GROUP *SchedulingGroup,
        _KSCHEDULING_GROUP_POLICY Policy,
        _KSCHEDULING_GROUP *Parent){
  LARGE_INTEGER PerformanceCounter; 
  bool v7; 
  $60E5399CB9BE4CDCAACA2C9004551315 *v8; 
  unsigned int v9; 
  unsigned __int64 *p_MinQuotaCycleTarget; 
  _QWORD *v11; 
  __int64 v12; 
  __int64 v13; 
  char v14; 
  _LIST_ENTRY *v15; 
  unsigned int v16; 
  unsigned int v17; 
  __int64 v18; 
  char *v19; 
  _QWORD *v20; 
  _QWORD *v21; 
  __int64 v22; 
  unsigned int ChildMinRate; 
  int Weight; 
  int v25; 
  _KSCHEDULING_GROUP *v26; 
  _KSCB *v27; 
  _LIST_ENTRY *Blink; 
  unsigned int ChildMinWeight; 
  int v30; 
  struct _KLOCK_QUEUE_HANDLE LockHandle; 
  UINT64 SpinCount; 
  _KSCHEDULING_GROUP_POLICY v33; 
  char *v34; 
  v33 = Policy;
  memset(&LockHandle, 0, sizeof(LockHandle));
  if( !KiGroupSchedulingEnabled )
    KiEnableGroupScheduling();
  SchedulingGroup->Policy = Policy;
  SchedulingGroup->NotificationCycles = 0i64;
  *(_QWORD *)&SchedulingGroup->ChildMinRate = 0i64;
  SchedulingGroup->ChildTotalWeight = 0;
  PerformanceCounter = KeQueryPerformanceCounter(0i64);
  v7 = (_DWORD)KeMaximumProcessors == 0;
  v8 = &SchedulingGroup->56;
  SchedulingGroup->QueryHistoryTimeStamp = PerformanceCounter.QuadPart;
  v9 = 0;
  SchedulingGroup->SchedulingGroupList.Blink = &SchedulingGroup->SchedulingGroupList;
  SchedulingGroup->ChildList.Blink = &SchedulingGroup->ChildList;
  SchedulingGroup->ChildList.Flink = &SchedulingGroup->ChildList;
  SchedulingGroup->SchedulingGroupList.Flink = &SchedulingGroup->SchedulingGroupList;
  SchedulingGroup->Parent = 0i64;
  SchedulingGroup->MaxQuotaLimitCycles = 0i64;
  SchedulingGroup->MaxQuotaCyclesRemaining = 0i64;
  if( !v7 )
  {
    p_MinQuotaCycleTarget = &SchedulingGroup->PerProcessor[0].MinQuotaCycleTarget;
    do
    {
      memset((INT64)(p_MinQuotaCycleTarget - 1), 0i64);
      v11 = p_MinQuotaCycleTarget + 16;
      v12 = 16i64;
      do
      {
        v11[1] = v11;
        *v11 = v11;
        v11 += 2;
        --v12;
      }
      while( v12 );
      v13 = KiCycleDivisorShortTerm;
      *p_MinQuotaCycleTarget = KiCycleDivisorShortTerm;
      p_MinQuotaCycleTarget[1] = v13;
      p_MinQuotaCycleTarget[48] = 0i64;
      p_MinQuotaCycleTarget[49] = 0i64;
      if( Parent )
      {
        v27 = &Parent->PerProcessor[v9];
        p_MinQuotaCycleTarget[50] = (unsigned __int64)v27;
        p_MinQuotaCycleTarget[51] = (unsigned __int64)v27->Root;
        v14 = v27->Depth + 1;
      }
      else
      {
        p_MinQuotaCycleTarget[50] = 0i64;
        v14 = 0;
        p_MinQuotaCycleTarget[51] = (unsigned __int64)(p_MinQuotaCycleTarget - 1);
      }
      *((_BYTE *)p_MinQuotaCycleTarget + 105) = v14;
      ++v9;
      p_MinQuotaCycleTarget += 53;
    }
    while( v9 < (unsigned int)KeMaximumProcessors );
  }
  KeAcquireInStackQueuedSpinLock(&KiSchedulingGroupLock, &LockHandle);
  if( Parent )
  {
    SchedulingGroup->Parent = Parent;
    Blink = Parent->ChildList.Blink;
    if( Blink->Flink != &Parent->ChildList )
      goto LABEL_53;
    v8->SchedulingGroupList.Flink = &Parent->ChildList;
    SchedulingGroup->SchedulingGroupList.Blink = Blink;
    Blink->Flink = &v8->SchedulingGroupList;
    Parent->ChildList.Blink = &v8->SchedulingGroupList;
  }
  else
  {
    v15 = (_LIST_ENTRY *)qword_140C31A18;
    if( *(_QWORD ***)qword_140C31A18 != &KiSchedulingGroupList )
      goto LABEL_53;
    v8->SchedulingGroupList.Flink = (_LIST_ENTRY *)&KiSchedulingGroupList;
    SchedulingGroup->SchedulingGroupList.Blink = v15;
    v15->Flink = &v8->SchedulingGroupList;
    qword_140C31A18 = (__int64)&SchedulingGroup->56;
  }
  v16 = KeNumberProcessors_0;
  v17 = 0;
  v34 = 0i64;
  if( (_DWORD)KeNumberProcessors_0 )
  {
    while( 1 )
    {
      v18 = (__int64)*(&KiProcessorBlock + v17);
      v19 = (char *)SchedulingGroup + 424 * v17;
      LODWORD(SpinCount) = 0;
      while( _interlockedbittestandset64((volatile signed __int32 *)(v18 + 48), 0i64) )
      {
        do
          KeYieldProcessorEx(&SpinCount);
        while( *(_QWORD *)(v18 + 48) );
      }
      v20 = *(_QWORD **)(v18 + 33296);
      v21 = v19 + 200;
      if( *v20 != v18 + 33288 )
        break;
      v7 = (v33.AllFlags & 4) == 0;
      *v21 = v18 + 33288;
      *((_QWORD *)v19 + 26) = v20;
      *v20 = v21;
      *(_QWORD *)(v18 + 33296) = v21;
      if( !v7 )
      {
        v19[240] |= 0xCu;
        *((_DWORD *)v19 + 61) = 1;
      }
      _InterlockedAnd64((volatile signed __int64 *)(v18 + 48), 0i64);
      if( *(_QWORD *)(v18 + 33856) )
      {
        if( *(_BYTE *)(v18 + 209) == *(_BYTE *)(*(_QWORD *)(v18 + 33864) + 593i64) )
        {
          v19[240] |= 0x20u;
          v22 = (__int64)(v19 + 256);
          v34 = v19 + 256;
        }
        else
        {
          v22 = (__int64)v34;
        }
        *((_QWORD *)v19 + 31) = v22;
      }
      if( ++v17 >= v16 )
        goto LABEL_24;
    }
LABEL_53:
    __fastfail(3u);
  }
LABEL_24:
  if( (SchedulingGroup->Policy.AllFlags & 1) != 0 )
  {
    if( Parent )
    {
      ChildMinRate = Parent->ChildMinRate;
      if( ChildMinRate )
      {
        Weight = Policy.Weight;
        if( Policy.Weight >= ChildMinRate )
          goto LABEL_28;
      }
      v26 = Parent;
      Parent->ChildMinRate = Policy.Weight;
    }
    else
    {
      ChildMinRate = KiGroupSchedulingMinimumRate;
      if( KiGroupSchedulingMinimumRate )
      {
        Weight = Policy.Weight;
        if( Policy.Weight >= (unsigned int)KiGroupSchedulingMinimumRate )
        {
LABEL_28:
          SchedulingGroup->RelativeWeight = (Weight << 7) / ChildMinRate;
LABEL_29:
          KiUpdateCpuTargetByRate(SchedulingGroup, 0);
          goto LABEL_30;
        }
      }
      v26 = 0i64;
      KiGroupSchedulingMinimumRate = Policy.Weight;
    }
    KiAssignSchedulingGroupWeights(1, 0, (__int64)v26);
    goto LABEL_29;
  }
  if( Parent )
  {
    ChildMinWeight = Parent->ChildMinWeight;
    if( !ChildMinWeight || (v30 = Policy.Weight, Policy.Weight < ChildMinWeight) )
    {
      v30 = Policy.Weight;
      Parent->ChildMinWeight = Policy.Weight;
    }
    Parent->ChildTotalWeight += v30;
  }
  else
  {
    if( !KiGroupSchedulingMinimumWeight
      || (v25 = Policy.Weight, Policy.Weight < (unsigned int)KiGroupSchedulingMinimumWeight) )
    {
      v25 = Policy.Weight;
      KiGroupSchedulingMinimumWeight = Policy.Weight;
    }
    KiGroupSchedulingTotalWeight += v25;
  }
  KiAssignSchedulingGroupWeights(0, 0, (__int64)Parent);
LABEL_30:
  KeReleaseInStackQueuedSpinLockFromDpcLevel(&LockHandle);
  __writecr8(LockHandle.OldIrql);
}

Referenced by: