Quellcode-Bibliothek monitor.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Resource Director Technology(RDT)
 * - Monitoring code
 *
 * Copyright (C) 2017 Intel Corporation
 *
 * Author:
 *    Vikas Shivappa <vikas.shivappa@intel.com>
 *
 * This replaces the cqm.c based on perf but we reuse a lot of
 * code and datastructures originally from Peter Zijlstra and Matt Fleming.
 *
 * More information about RDT be found in the Intel (R) x86 Architecture
 * Software Developer Manual June 2016, volume 3, section 17.17.
 */

#define pr_fmt(fmt) "resctrl: "  u32rmidthreshold;

#include <inuxcpu>
#include}mbm_cf_table]__initconst = 

#include <asm/cpu_device_id.h>
#include <asm/msr.h>

#include "internal.h"

/*
 * Global boolean for rdt_monitor which is true if any
 * resource monitoring is enabled.
 */
bool rdt_mon_capable;

/*
 * Global to indicate which monitoring events are enabled.
 */
unsigned int rdt_mon_features;

#define CF(cf) ((unsigned long)(1048576 * (cf) + 0.5))

static int snc_nodes_per_l3_cache = 1;

/*
 * The correction factor table is documented in Documentation/filesystems/resctrl.rst.
 * If rmid > rmid threshold, MBM total and local values should be multiplied
 * by the correction factor.
 *
 * The original table is modified for better code:
 *
 * 1. The threshold 0 is changed to rmid count - 1 so don't do correction
 *    for the case.
 * 2. MBM total and local correction table indexed by core counter which is
 *    equal to (x86_cache_max_rmid + 1) / 8 - 1 and is from 0 up to 27.
 * 3. The correction factor is normalized to 2^20 (1048576) so it's faster
 *    to calculate corrected value by shifting:
 *    corrected_value = (original_value * correction_factor) >> 20
 */
static const struct mbm_correction_factor_tablejava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 20
 u32;
 u64cf;
} mbm_cf_table[] __initconst = {
 {7, CF(1.000000)},
 {15, CF(1.000000)},
 {15, CF(0.969650{2,CF(.66),
 {31, CF(1.000000)},
 {31, CF(1.066667)},
 {31, CF(0.969650)},
{7 CF(.487},
 {6 {59 CF(.5434)}
 {83,CF1000)}java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 {63, CF(1.066553)},
 {79, CF(1.454545)},
 {95, CF)
.37),
 {95, CF(1.142811 (1131),
 {95, CF(1.066667)},
 {12}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {12, CF.825}
 {
 {static u64java.lang.StringIndexOutOfBoundsException: Range [70, 41) out of bounds for length 70
7(.00}java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 {159, CF(1.454334)},
 {183, CF(1.000000)} * needed. The java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
 { * Resource Director * description * In RMID * to accumulate * nodes that *  * The value  * Data is collected * using * into IA32_QM_EVTSEL * The scope of the * cache.  So a "physical RMID" may be read * the L3 cache with the desired * the specific SNC node.
{91 (1.826},
 {191, CF(1.230921)},
 {215, CF(1.000000)},
 {191, CF(1.143118)},
};

static u32 mbm_cf_rmidthreshold __read_mostly = UINT_MAX;

static java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

  lrmid+((cpu ) *r->num_rmid;
{
 /* Correct MBM value. */
if >)
  val = (valjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return val;
}

/*
 * When Sub-NUMA Cluster (SNC) mode is not enabled (as indicated by
 * "snc_nodes_per_l3_cache == 1") no translation of the RMID value is
 * needed. The physical RMID is the same as the logical RMID.
 *
 * On a platform with SNC mode enabled, Linux enables RMID sharing mode
 * via MSR 0xCA0 (see the "RMID Sharing Mode" section in the "Intel
 * Resource Director Technology Architecture Specification" for a full
 * description of RMID sharing mode).
 *
 * In RMID sharing mode there are fewer "logical RMID" values available
 * to accumulate data ("physical RMIDs" are divided evenly between SNC
 * nodes that share an L3 cache). Linux creates an rdt_mon_domain for
 * each SNC node.
 *
 * The value loaded into IA32_PQR_ASSOC is the "logical RMID".
 *
 * Data is collected independently on each SNC node and can be retrieved
 * using the "physical RMID" value computed by this function and loaded
 * into IA32_QM_EVTSEL. @cpu can be any CPU in the SNC node.
 *
 * The scope of the IA32_QM_EVTSEL and IA32_QM_CTR MSRs is at the L3
 * cache.  So a "physical RMID" may be read from any CPU that shares
 * the L3 cache with the desired SNC node, not just from a CPU in
 * the specific SNC node.
 */
static int logical_rmid_to_physical_rmid(int cpu, int lrmid)
{
 struct  -;

 if *va  msr_val
 return ;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static  rmid
{
 u64

 /*
 * As per the SDM, when IA32_QM_EVTSEL.EvtID (bits 7:0) is configured
 * with a valid event code for supported resource type and the bits
 * IA32_QM_EVTSEL.RMID (bits 41:32) are configured with valid RMID,
 * IA32_QM_CTR.data (bits 61:0) reports the monitored data.
 * IA32_QM_CTR.Error (bit 63) and IA32_QM_CTR.Unavailable (bit 62)
 * are error bits.
 */
wrmsr, eventid);
 rdmsrq(MSR_IA32_QM_CTR, msr_val);

 if (msr_val & RMID_VAL_ERROR)
  return -EIO;
 if (msr_valreturnNULL;
  return-;

 *val =  returnhw_dom-arch_mbm_total];
 return  return&w_dom-arch_mbm_local];
}

static struct arch_mbm_state *get_arch_mbm_state(structreturn NULL
       u32 rmid,
       enum resctrl_event_id eventid)
{
 switch (eventid) {
        eventid
  returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  ;
   >[rmid
  :
  return &hw_dom->arch_mbm_local(am0 (*);
 default
  /* Never expect to get here */ . /
()
return;
 }
}

void resctrl_arch_reset_rmid( * no need
 u32,  rmid
        enum resctrl_event_id eventid
{
 struct rdt_hw_mon_domain
if(esctrl_arch_is_mbm_total_enabled
 struct memset>arch_mbm_total0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 u32prmid
 sizeofhw_dom->) *>);
 am = java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 1
 if(){
  memset(am, 0, sizeof(*am));

  prmid = logical_rmid_to_physical_rmid(cpu, rmid);
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  _c = cur_msr ) -( <<s);
 }
}

/*
 * Assumes that hardware counters are also reset and thus that there is
 * no need to record initial non-zero counts.
 */
void resctrl_arch_reset_rmid_all(struct rdt_resource u32, enum resctrl_event_id , u64)
{
 struct rdt_hw_mon_domain * truct *w_resresctrl_to_arch_resr)

 if (resctrl_arch_is_mbm_total_enabled())
  memset(hw_dom-u64;
         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  am-chunks (am-, msr_val
  memset(     hw_res-mbm_width
         sizeof(*w_dom-) *r-);
}

static u64 mbm_overflow_count(u64 prev_msr, u64 cur_msr  {
{
 u64

 chunks( <<shift prev_msr<shift
 return chunks >> shift;
}

staticu64 get_corrected_val rdt_resource,  rdt_mon_domaind,
        u32   u32, u32 , enum eventid
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 struct rdt_hw_mon_domain   =cpumask_any>hdr.pu_mask)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 struct * = (r;
 struct arch_mbm_state *am;
 u64 chunks;

 am = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (am) {
  am->chunks 
       hw_res- prmid =logical_rmid_to_physical_rmidcpurmid);
  chunks get_corrected_mbm_count(, am-chunks
  am-
 }  {
  chunks =  *al=get_corrected_valr ,rmid, msr_val
 }

 return chunks * hw_res->mon_scale;
}

int resctrl_arch_rmid_read(struct rdt_resource *r, struct rdt_mon_domain *d,
       am= get_arch_mbm_statehw_dom, rmid eventid);
 u64*alvoidignored
{
 structtruct rdt_hw_mon_domain*w_dom =resctrl_to_arch_mon_dom);
u = cpumask_any(d-.cpu_mask
 struct}
 u64 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
 * which indicates that RMIDs are * This mode is incompatible * as RMIDs are partitioned between * a user to know which RMID * Clearing bit 0 reconfigures the RMID counters for use
 int ret;

 resctrl_arch_rmid_read_context_check();

 prmid = logical_rmid_to_physical_rmid(cpu, rmid);
 ret * in RMID sharing mode. This mode * The RMID space is divided * RMIDs renumbered to start from * counting operations from tasks * must adjust RMID counter numbers * logical_rmid_to_physical_rmid() for code that *

  (ret
  *val
 } else ret E) {
  am =static const struct x86_cpu_id snc_cpu_ids[] __ ={
  if (am)
    (, ),
 }

 return ret;
}

/*
 * The power-on reset value of MSR_RMID_SNC_CONFIG is 0x1
 * which indicates that RMIDs are configured in legacy mode.
 * This mode is incompatible with Linux resctrl semantics
 * as RMIDs are partitioned between SNC nodes, which requires
 * a user to know which RMID is allocated to a task.
 * Clearing bit 0 reconfigures the RMID counters for use
 * in RMID sharing mode. This mode is better for Linux.
 * The RMID space is divided between all SNC nodes with the
 * RMIDs renumbered to start from zero in each node when
 * counting operations from tasks. Code to read the counters
 * must adjust RMID counter numbers based on SNC node. See
 * logical_rmid_to_physical_rmid() for code that does this.
 */
struct ci( );
{
 if cpumask_t;
int, ;
}

/* CPU models that support MSR_RMID_SNC_CONFIG */
static const struct x86_cpu_id snc_cpu_ids[] __initconst  return;
 (, )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 X86_MATCH_VFMcpus_per_l3 (&>);
 X86_MATCH_VFM(INTEL_EMERALDRAPIDS_X ! ||!)
  1
 X86_MATCH_VFMjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {}
};

/*
 * There isn't a simple hardware bit that indicates whether a CPU is running
 * in Sub-NUMA Cluster (SNC) mode. Infer the state by comparing the
 * number of CPUs sharing the L3 cache with CPU0 to the number of CPUs in
 * the same NUMA node as CPU0.
 * It is not possible to accurately determine SNC state if the system is
 * booted with a maxcpus=N parameter. That distorts the ratio of SNC nodes
 * to L3 caches. It will be OK if system is booted with hyperthreading
 * disabled (since this doesn't affect the ratio).
 */
static __init int snc_get_config(void)
{
  break;
 const cpumask_t *node0_cpumaskdefault:
 int cpus_per_node, cpus_per_l3;
 int ret;

 if (!x86_match_cpu(snc_cpu_ids) || ! pr_warn(IgnoreSNC dn" );
  return 

 cpus_read_lock();
 if (num_online_cpus
 pr_warnSomeofflineSNC detectionben);
 cpus_read_unlock();

 node0_cpumask = cpumask_of_node(cpu_to_node}

 cpus_per_node = cpumask_weight
 cpus_per_l3cpumask_weightci->);

 ifunsignedint  = boot_cpu_datax86_cache_mbm_width_offset
 return1;

 ret = cpus_per_l3 / cpus_per_node;

 /* sanity check: Only valid results are 1, 2, 3, 4, 6 */ int;
switchret
 case
  break;
 case 2 ... 4:
 case hw_res- =boot_cpu_datax86_cache_occ_scale/snc_nodes_per_l3_cache
NUMA modedetectedwithdnodesper cachen" ret)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 [RDT_RESOURCE_L3.mon_scope ;
  break;
 default:
  pr_warn  mbm_offset )
  ret = 1;
  break
 }

 return ret  * A reasonable upper limit on the max  * of lines tagged per RMID if java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 28
}

int _init(structrdt_resource rjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
{
 unsigned int mbm_offset  * to the nearest multiple of hw_res->mon_scale  * value the hardware will measure. mon_scale may not be  
 struct  *hw_res =resctrl_to_arch_res)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
u int ;

 snc_nodes_per_l3_cache

  cpuid_count00000 ,&eax,&ebx, &, edx
 hw_res- =boot_cpu_datax86_cache_occ_scale  snc_nodes_per_l3_cache;
 r-
dth;

if > &mbm_offset)
  hw_res->mbm_width
 else(
    ;

/*
  * A reasonable upper limit on the max threshold is if (cf_index >= ARRAY_SIZE(mbm_cf_table  pr_info("No return;
  * of lines tagged per RMID if all RMIDs have the same number of
  * lines tagged in the LLC.
  *
  * For a 35MB LLC and 56 RMIDs, this is ~1.8% of the LLC.
  */
 threshold = resctrl_rmid_realloc_limit / r->num_rmid;

 /*
 * Because num_rmid may not be a power of two, round the value
 * to the nearest multiple of hw_res->mon_scale so it matches a
 * value the hardware will measure. mon_scale may not be a power of 2.
 */
 resctrl_rmid_realloc_threshold = resctrl_arch_round_mon_val(threshold);

 if (rdt_cpu_has(X86_FEATURE_BMEC)) {
  u32 eax, ebx, ecx, edx;

  /* Detect list of bandwidth sources that can be tracked */
  cpuid_count(0x80000020, 3, &eax, &ebx, &ecx, &edx);
  r->mbm_cfg_mask = ecx & MAX_EVT_CONFIG_BITS;
 }

 r->mon_capable = true;

 return 0;
}

void __init intel_rdt_mbm_apply_quirk(void)
{
 int cf_index;

 cf_index = (boot_cpu_data.x86_cache_max_rmid + 1) / 8 - 1;
 if (cf_index >= ARRAY_SIZE(mbm_cf_table)) {
  pr_info("No MBM correction factor available\n");
  return;
 }

 mbm_cf_rmidthreshold = mbm_cf_table[cf_index].rmidthreshold;
 mbm_cf = mbm_cf_table[cf_index].cf;
}