KeInsertSchedulingGroup

VOID __stdcall KeInsertSchedulingGroup(
        _KSCHEDULING_GROUP *SchedulingGroup,
        _KSCHEDULING_GROUP_POLICY Policy,
        _KSCHEDULING_GROUP *Parent){
  unsigned __int64 PerformanceCounter; 
  bool v7; 
  $60E5399CB9BE4CDCAACA2C9004551315 *v8; 
  unsigned int v9; 
  unsigned __int64 *p_MinQuotaCycleTarget; 
  _QWORD *v11; 
  __int64 v12; 
  __int64 v13; 
  char v14; 
  _KPRCB *v15; 
  _LIST_ENTRY *v16; 
  unsigned int v17; 
  unsigned int v18; 
  __int64 v19; 
  char *v20; 
  _QWORD *v21; 
  _QWORD *v22; 
  __int64 v23; 
  unsigned int ChildMinRate; 
  int Weight; 
  int v26; 
  _KSCHEDULING_GROUP *v27; 
  _KSCB *v28; 
  _LIST_ENTRY *Blink; 
  unsigned int ChildMinWeight; 
  int v31; 
  _KLOCK_QUEUE_HANDLE LockHandle; 
  UINT64 SpinCount; 
  _KSCHEDULING_GROUP_POLICY v34; 
  char *v35; 

  v34 = 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;
  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(p_MinQuotaCycleTarget - 1, 0i64, 0x88u);
      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 )
      {
        v28 = &Parent->PerProcessor[v9];
        p_MinQuotaCycleTarget[50] = (unsigned __int64)v28;
        p_MinQuotaCycleTarget[51] = (unsigned __int64)v28->Root;
        v14 = v28->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((PKSPIN_LOCK)&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
  {
    v16 = (_LIST_ENTRY *)qword_140C31A18;
    if( *(__int64 **)qword_140C31A18 != &KiSchedulingGroupList )
      goto LABEL_53;
    v8->SchedulingGroupList.Flink = (_LIST_ENTRY *)&KiSchedulingGroupList;
    SchedulingGroup->SchedulingGroupList.Blink = v16;
    v16->Flink = &v8->SchedulingGroupList;
    qword_140C31A18 = (__int64)&SchedulingGroup->56;
  }
  v17 = KeNumberProcessors_0;
  v18 = 0;
  v35 = 0i64;
  if( (_DWORD)KeNumberProcessors_0 )
  {
    while( 1 )
    {
      v19 = (__int64)*(&KiProcessorBlock + v18);
      v20 = (char *)SchedulingGroup + 424 * v18;
      LODWORD(SpinCount) = 0;
      while( _interlockedbittestandset64((volatile signed __int32 *)(v19 + 48), 0i64) )
      {
        do
          KeYieldProcessorEx(&SpinCount);
        while( *(_QWORD *)(v19 + 48) );
      }
      v21 = *(_QWORD **)(v19 + 33296);
      v22 = v20 + 200;
      if( *v21 != v19 + 33288 )
        break;
      v7 = (v34.AllFlags & 4) == 0;
      *v22 = v19 + 33288;
      *((_QWORD *)v20 + 26) = v21;
      *v21 = v22;
      *(_QWORD *)(v19 + 33296) = v22;
      if( !v7 )
      {
        v20[240] |= 0xCu;
        *((_DWORD *)v20 + 61) = 1;
      }
      _InterlockedAnd64((volatile signed __int64 *)(v19 + 48), 0i64);
      if( *(_QWORD *)(v19 + 33856) )
      {
        if( *(_BYTE *)(v19 + 209) == *(_BYTE *)(*(_QWORD *)(v19 + 33864) + 593i64) )
        {
          v20[240] |= 0x20u;
          v23 = (__int64)(v20 + 256);
          v35 = v20 + 256;
        }
        else
        {
          v23 = (__int64)v35;
        }
        *((_QWORD *)v20 + 31) = v23;
      }
      if( ++v18 >= v17 )
        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;
      }
      v27 = 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, v15);
          goto LABEL_30;
        }
      }
      v27 = 0i64;
      KiGroupSchedulingMinimumRate = Policy.Weight;
    }
    KiAssignSchedulingGroupWeights(RateBased, 0, v27);
    goto LABEL_29;
  }
  if( Parent )
  {
    ChildMinWeight = Parent->ChildMinWeight;
    if( !ChildMinWeight || (v31 = Policy.Weight, Policy.Weight < ChildMinWeight) )
    {
      v31 = Policy.Weight;
      Parent->ChildMinWeight = Policy.Weight;
    }
    Parent->ChildTotalWeight += v31;
  }
  else
  {
    if( !KiGroupSchedulingMinimumWeight
      || (v26 = Policy.Weight, Policy.Weight < (unsigned int)KiGroupSchedulingMinimumWeight) )
    {
      v26 = Policy.Weight;
      KiGroupSchedulingMinimumWeight = Policy.Weight;
    }
    KiGroupSchedulingTotalWeight += v26;
  }
  KiAssignSchedulingGroupWeights(WeightBased, 0, Parent);
LABEL_30:
  KeReleaseInStackQueuedSpinLockFromDpcLevel(&LockHandle);
  __writecr8(LockHandle.OldIrql);
}

Referenced by: