1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Resource Director Technology(RDT) 4 * - Monitoring code 5 * 6 * Copyright (C) 2017 Intel Corporation 7 * 8 * Author: 9 * Vikas Shivappa <vikas.shivappa@intel.com> 10 * 11 * This replaces the cqm.c based on perf but we reuse a lot of 12 * code and datastructures originally from Peter Zijlstra and Matt Fleming. 13 * 14 * More information about RDT be found in the Intel (R) x86 Architecture 15 * Software Developer Manual June 2016, volume 3, section 17.17. 16 */ 17 18 #include <linux/module.h> 19 #include <linux/slab.h> 20 #include <asm/cpu_device_id.h> 21 #include "internal.h" 22 23 struct rmid_entry { 24 u32 rmid; 25 int busy; 26 struct list_head list; 27 }; 28 29 /** 30 * @rmid_free_lru A least recently used list of free RMIDs 31 * These RMIDs are guaranteed to have an occupancy less than the 32 * threshold occupancy 33 */ 34 static LIST_HEAD(rmid_free_lru); 35 36 /** 37 * @rmid_limbo_count count of currently unused but (potentially) 38 * dirty RMIDs. 39 * This counts RMIDs that no one is currently using but that 40 * may have a occupancy value > intel_cqm_threshold. User can change 41 * the threshold occupancy value. 42 */ 43 static unsigned int rmid_limbo_count; 44 45 /** 46 * @rmid_entry - The entry in the limbo and free lists. 47 */ 48 static struct rmid_entry *rmid_ptrs; 49 50 /* 51 * Global boolean for rdt_monitor which is true if any 52 * resource monitoring is enabled. 53 */ 54 bool rdt_mon_capable; 55 56 /* 57 * Global to indicate which monitoring events are enabled. 58 */ 59 unsigned int rdt_mon_features; 60 61 /* 62 * This is the threshold cache occupancy at which we will consider an 63 * RMID available for re-allocation. 64 */ 65 unsigned int resctrl_cqm_threshold; 66 67 #define CF(cf) ((unsigned long)(1048576 * (cf) + 0.5)) 68 69 /* 70 * The correction factor table is documented in Documentation/x86/resctrl.rst. 71 * If rmid > rmid threshold, MBM total and local values should be multiplied 72 * by the correction factor. 73 * 74 * The original table is modified for better code: 75 * 76 * 1. The threshold 0 is changed to rmid count - 1 so don't do correction 77 * for the case. 78 * 2. MBM total and local correction table indexed by core counter which is 79 * equal to (x86_cache_max_rmid + 1) / 8 - 1 and is from 0 up to 27. 80 * 3. The correction factor is normalized to 2^20 (1048576) so it's faster 81 * to calculate corrected value by shifting: 82 * corrected_value = (original_value * correction_factor) >> 20 83 */ 84 static const struct mbm_correction_factor_table { 85 u32 rmidthreshold; 86 u64 cf; 87 } mbm_cf_table[] __initconst = { 88 {7, CF(1.000000)}, 89 {15, CF(1.000000)}, 90 {15, CF(0.969650)}, 91 {31, CF(1.000000)}, 92 {31, CF(1.066667)}, 93 {31, CF(0.969650)}, 94 {47, CF(1.142857)}, 95 {63, CF(1.000000)}, 96 {63, CF(1.185115)}, 97 {63, CF(1.066553)}, 98 {79, CF(1.454545)}, 99 {95, CF(1.000000)}, 100 {95, CF(1.230769)}, 101 {95, CF(1.142857)}, 102 {95, CF(1.066667)}, 103 {127, CF(1.000000)}, 104 {127, CF(1.254863)}, 105 {127, CF(1.185255)}, 106 {151, CF(1.000000)}, 107 {127, CF(1.066667)}, 108 {167, CF(1.000000)}, 109 {159, CF(1.454334)}, 110 {183, CF(1.000000)}, 111 {127, CF(0.969744)}, 112 {191, CF(1.280246)}, 113 {191, CF(1.230921)}, 114 {215, CF(1.000000)}, 115 {191, CF(1.143118)}, 116 }; 117 118 static u32 mbm_cf_rmidthreshold __read_mostly = UINT_MAX; 119 static u64 mbm_cf __read_mostly; 120 121 static inline u64 get_corrected_mbm_count(u32 rmid, unsigned long val) 122 { 123 /* Correct MBM value. */ 124 if (rmid > mbm_cf_rmidthreshold) 125 val = (val * mbm_cf) >> 20; 126 127 return val; 128 } 129 130 static inline struct rmid_entry *__rmid_entry(u32 rmid) 131 { 132 struct rmid_entry *entry; 133 134 entry = &rmid_ptrs[rmid]; 135 WARN_ON(entry->rmid != rmid); 136 137 return entry; 138 } 139 140 static u64 __rmid_read(u32 rmid, u32 eventid) 141 { 142 u64 val; 143 144 /* 145 * As per the SDM, when IA32_QM_EVTSEL.EvtID (bits 7:0) is configured 146 * with a valid event code for supported resource type and the bits 147 * IA32_QM_EVTSEL.RMID (bits 41:32) are configured with valid RMID, 148 * IA32_QM_CTR.data (bits 61:0) reports the monitored data. 149 * IA32_QM_CTR.Error (bit 63) and IA32_QM_CTR.Unavailable (bit 62) 150 * are error bits. 151 */ 152 wrmsr(MSR_IA32_QM_EVTSEL, eventid, rmid); 153 rdmsrl(MSR_IA32_QM_CTR, val); 154 155 return val; 156 } 157 158 static bool rmid_dirty(struct rmid_entry *entry) 159 { 160 u64 val = __rmid_read(entry->rmid, QOS_L3_OCCUP_EVENT_ID); 161 162 return val >= resctrl_cqm_threshold; 163 } 164 165 /* 166 * Check the RMIDs that are marked as busy for this domain. If the 167 * reported LLC occupancy is below the threshold clear the busy bit and 168 * decrement the count. If the busy count gets to zero on an RMID, we 169 * free the RMID 170 */ 171 void __check_limbo(struct rdt_domain *d, bool force_free) 172 { 173 struct rmid_entry *entry; 174 struct rdt_resource *r; 175 u32 crmid = 1, nrmid; 176 177 r = &rdt_resources_all[RDT_RESOURCE_L3]; 178 179 /* 180 * Skip RMID 0 and start from RMID 1 and check all the RMIDs that 181 * are marked as busy for occupancy < threshold. If the occupancy 182 * is less than the threshold decrement the busy counter of the 183 * RMID and move it to the free list when the counter reaches 0. 184 */ 185 for (;;) { 186 nrmid = find_next_bit(d->rmid_busy_llc, r->num_rmid, crmid); 187 if (nrmid >= r->num_rmid) 188 break; 189 190 entry = __rmid_entry(nrmid); 191 if (force_free || !rmid_dirty(entry)) { 192 clear_bit(entry->rmid, d->rmid_busy_llc); 193 if (!--entry->busy) { 194 rmid_limbo_count--; 195 list_add_tail(&entry->list, &rmid_free_lru); 196 } 197 } 198 crmid = nrmid + 1; 199 } 200 } 201 202 bool has_busy_rmid(struct rdt_resource *r, struct rdt_domain *d) 203 { 204 return find_first_bit(d->rmid_busy_llc, r->num_rmid) != r->num_rmid; 205 } 206 207 /* 208 * As of now the RMIDs allocation is global. 209 * However we keep track of which packages the RMIDs 210 * are used to optimize the limbo list management. 211 */ 212 int alloc_rmid(void) 213 { 214 struct rmid_entry *entry; 215 216 lockdep_assert_held(&rdtgroup_mutex); 217 218 if (list_empty(&rmid_free_lru)) 219 return rmid_limbo_count ? -EBUSY : -ENOSPC; 220 221 entry = list_first_entry(&rmid_free_lru, 222 struct rmid_entry, list); 223 list_del(&entry->list); 224 225 return entry->rmid; 226 } 227 228 static void add_rmid_to_limbo(struct rmid_entry *entry) 229 { 230 struct rdt_resource *r; 231 struct rdt_domain *d; 232 int cpu; 233 u64 val; 234 235 r = &rdt_resources_all[RDT_RESOURCE_L3]; 236 237 entry->busy = 0; 238 cpu = get_cpu(); 239 list_for_each_entry(d, &r->domains, list) { 240 if (cpumask_test_cpu(cpu, &d->cpu_mask)) { 241 val = __rmid_read(entry->rmid, QOS_L3_OCCUP_EVENT_ID); 242 if (val <= resctrl_cqm_threshold) 243 continue; 244 } 245 246 /* 247 * For the first limbo RMID in the domain, 248 * setup up the limbo worker. 249 */ 250 if (!has_busy_rmid(r, d)) 251 cqm_setup_limbo_handler(d, CQM_LIMBOCHECK_INTERVAL); 252 set_bit(entry->rmid, d->rmid_busy_llc); 253 entry->busy++; 254 } 255 put_cpu(); 256 257 if (entry->busy) 258 rmid_limbo_count++; 259 else 260 list_add_tail(&entry->list, &rmid_free_lru); 261 } 262 263 void free_rmid(u32 rmid) 264 { 265 struct rmid_entry *entry; 266 267 if (!rmid) 268 return; 269 270 lockdep_assert_held(&rdtgroup_mutex); 271 272 entry = __rmid_entry(rmid); 273 274 if (is_llc_occupancy_enabled()) 275 add_rmid_to_limbo(entry); 276 else 277 list_add_tail(&entry->list, &rmid_free_lru); 278 } 279 280 static u64 mbm_overflow_count(u64 prev_msr, u64 cur_msr, unsigned int width) 281 { 282 u64 shift = 64 - width, chunks; 283 284 chunks = (cur_msr << shift) - (prev_msr << shift); 285 return chunks >>= shift; 286 } 287 288 static u64 __mon_event_count(u32 rmid, struct rmid_read *rr) 289 { 290 struct mbm_state *m; 291 u64 chunks, tval; 292 293 tval = __rmid_read(rmid, rr->evtid); 294 if (tval & (RMID_VAL_ERROR | RMID_VAL_UNAVAIL)) { 295 return tval; 296 } 297 switch (rr->evtid) { 298 case QOS_L3_OCCUP_EVENT_ID: 299 rr->val += tval; 300 return 0; 301 case QOS_L3_MBM_TOTAL_EVENT_ID: 302 m = &rr->d->mbm_total[rmid]; 303 break; 304 case QOS_L3_MBM_LOCAL_EVENT_ID: 305 m = &rr->d->mbm_local[rmid]; 306 break; 307 } 308 309 if (rr->first) { 310 memset(m, 0, sizeof(struct mbm_state)); 311 m->prev_bw_msr = m->prev_msr = tval; 312 return 0; 313 } 314 315 chunks = mbm_overflow_count(m->prev_msr, tval, rr->r->mbm_width); 316 m->chunks += chunks; 317 m->prev_msr = tval; 318 319 rr->val += get_corrected_mbm_count(rmid, m->chunks); 320 321 return 0; 322 } 323 324 /* 325 * Supporting function to calculate the memory bandwidth 326 * and delta bandwidth in MBps. 327 */ 328 static void mbm_bw_count(u32 rmid, struct rmid_read *rr) 329 { 330 struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_L3]; 331 struct mbm_state *m = &rr->d->mbm_local[rmid]; 332 u64 tval, cur_bw, chunks; 333 334 tval = __rmid_read(rmid, rr->evtid); 335 if (tval & (RMID_VAL_ERROR | RMID_VAL_UNAVAIL)) 336 return; 337 338 chunks = mbm_overflow_count(m->prev_bw_msr, tval, rr->r->mbm_width); 339 cur_bw = (get_corrected_mbm_count(rmid, chunks) * r->mon_scale) >> 20; 340 341 if (m->delta_comp) 342 m->delta_bw = abs(cur_bw - m->prev_bw); 343 m->delta_comp = false; 344 m->prev_bw = cur_bw; 345 m->prev_bw_msr = tval; 346 } 347 348 /* 349 * This is called via IPI to read the CQM/MBM counters 350 * on a domain. 351 */ 352 void mon_event_count(void *info) 353 { 354 struct rdtgroup *rdtgrp, *entry; 355 struct rmid_read *rr = info; 356 struct list_head *head; 357 u64 ret_val; 358 359 rdtgrp = rr->rgrp; 360 361 ret_val = __mon_event_count(rdtgrp->mon.rmid, rr); 362 363 /* 364 * For Ctrl groups read data from child monitor groups and 365 * add them together. Count events which are read successfully. 366 * Discard the rmid_read's reporting errors. 367 */ 368 head = &rdtgrp->mon.crdtgrp_list; 369 370 if (rdtgrp->type == RDTCTRL_GROUP) { 371 list_for_each_entry(entry, head, mon.crdtgrp_list) { 372 if (__mon_event_count(entry->mon.rmid, rr) == 0) 373 ret_val = 0; 374 } 375 } 376 377 /* Report error if none of rmid_reads are successful */ 378 if (ret_val) 379 rr->val = ret_val; 380 } 381 382 /* 383 * Feedback loop for MBA software controller (mba_sc) 384 * 385 * mba_sc is a feedback loop where we periodically read MBM counters and 386 * adjust the bandwidth percentage values via the IA32_MBA_THRTL_MSRs so 387 * that: 388 * 389 * current bandwidth(cur_bw) < user specified bandwidth(user_bw) 390 * 391 * This uses the MBM counters to measure the bandwidth and MBA throttle 392 * MSRs to control the bandwidth for a particular rdtgrp. It builds on the 393 * fact that resctrl rdtgroups have both monitoring and control. 394 * 395 * The frequency of the checks is 1s and we just tag along the MBM overflow 396 * timer. Having 1s interval makes the calculation of bandwidth simpler. 397 * 398 * Although MBA's goal is to restrict the bandwidth to a maximum, there may 399 * be a need to increase the bandwidth to avoid unnecessarily restricting 400 * the L2 <-> L3 traffic. 401 * 402 * Since MBA controls the L2 external bandwidth where as MBM measures the 403 * L3 external bandwidth the following sequence could lead to such a 404 * situation. 405 * 406 * Consider an rdtgroup which had high L3 <-> memory traffic in initial 407 * phases -> mba_sc kicks in and reduced bandwidth percentage values -> but 408 * after some time rdtgroup has mostly L2 <-> L3 traffic. 409 * 410 * In this case we may restrict the rdtgroup's L2 <-> L3 traffic as its 411 * throttle MSRs already have low percentage values. To avoid 412 * unnecessarily restricting such rdtgroups, we also increase the bandwidth. 413 */ 414 static void update_mba_bw(struct rdtgroup *rgrp, struct rdt_domain *dom_mbm) 415 { 416 u32 closid, rmid, cur_msr, cur_msr_val, new_msr_val; 417 struct mbm_state *pmbm_data, *cmbm_data; 418 u32 cur_bw, delta_bw, user_bw; 419 struct rdt_resource *r_mba; 420 struct rdt_domain *dom_mba; 421 struct list_head *head; 422 struct rdtgroup *entry; 423 424 if (!is_mbm_local_enabled()) 425 return; 426 427 r_mba = &rdt_resources_all[RDT_RESOURCE_MBA]; 428 closid = rgrp->closid; 429 rmid = rgrp->mon.rmid; 430 pmbm_data = &dom_mbm->mbm_local[rmid]; 431 432 dom_mba = get_domain_from_cpu(smp_processor_id(), r_mba); 433 if (!dom_mba) { 434 pr_warn_once("Failure to get domain for MBA update\n"); 435 return; 436 } 437 438 cur_bw = pmbm_data->prev_bw; 439 user_bw = dom_mba->mbps_val[closid]; 440 delta_bw = pmbm_data->delta_bw; 441 cur_msr_val = dom_mba->ctrl_val[closid]; 442 443 /* 444 * For Ctrl groups read data from child monitor groups. 445 */ 446 head = &rgrp->mon.crdtgrp_list; 447 list_for_each_entry(entry, head, mon.crdtgrp_list) { 448 cmbm_data = &dom_mbm->mbm_local[entry->mon.rmid]; 449 cur_bw += cmbm_data->prev_bw; 450 delta_bw += cmbm_data->delta_bw; 451 } 452 453 /* 454 * Scale up/down the bandwidth linearly for the ctrl group. The 455 * bandwidth step is the bandwidth granularity specified by the 456 * hardware. 457 * 458 * The delta_bw is used when increasing the bandwidth so that we 459 * dont alternately increase and decrease the control values 460 * continuously. 461 * 462 * For ex: consider cur_bw = 90MBps, user_bw = 100MBps and if 463 * bandwidth step is 20MBps(> user_bw - cur_bw), we would keep 464 * switching between 90 and 110 continuously if we only check 465 * cur_bw < user_bw. 466 */ 467 if (cur_msr_val > r_mba->membw.min_bw && user_bw < cur_bw) { 468 new_msr_val = cur_msr_val - r_mba->membw.bw_gran; 469 } else if (cur_msr_val < MAX_MBA_BW && 470 (user_bw > (cur_bw + delta_bw))) { 471 new_msr_val = cur_msr_val + r_mba->membw.bw_gran; 472 } else { 473 return; 474 } 475 476 cur_msr = r_mba->msr_base + closid; 477 wrmsrl(cur_msr, delay_bw_map(new_msr_val, r_mba)); 478 dom_mba->ctrl_val[closid] = new_msr_val; 479 480 /* 481 * Delta values are updated dynamically package wise for each 482 * rdtgrp every time the throttle MSR changes value. 483 * 484 * This is because (1)the increase in bandwidth is not perfectly 485 * linear and only "approximately" linear even when the hardware 486 * says it is linear.(2)Also since MBA is a core specific 487 * mechanism, the delta values vary based on number of cores used 488 * by the rdtgrp. 489 */ 490 pmbm_data->delta_comp = true; 491 list_for_each_entry(entry, head, mon.crdtgrp_list) { 492 cmbm_data = &dom_mbm->mbm_local[entry->mon.rmid]; 493 cmbm_data->delta_comp = true; 494 } 495 } 496 497 static void mbm_update(struct rdt_resource *r, struct rdt_domain *d, int rmid) 498 { 499 struct rmid_read rr; 500 501 rr.first = false; 502 rr.r = r; 503 rr.d = d; 504 505 /* 506 * This is protected from concurrent reads from user 507 * as both the user and we hold the global mutex. 508 */ 509 if (is_mbm_total_enabled()) { 510 rr.evtid = QOS_L3_MBM_TOTAL_EVENT_ID; 511 __mon_event_count(rmid, &rr); 512 } 513 if (is_mbm_local_enabled()) { 514 rr.evtid = QOS_L3_MBM_LOCAL_EVENT_ID; 515 __mon_event_count(rmid, &rr); 516 517 /* 518 * Call the MBA software controller only for the 519 * control groups and when user has enabled 520 * the software controller explicitly. 521 */ 522 if (is_mba_sc(NULL)) 523 mbm_bw_count(rmid, &rr); 524 } 525 } 526 527 /* 528 * Handler to scan the limbo list and move the RMIDs 529 * to free list whose occupancy < threshold_occupancy. 530 */ 531 void cqm_handle_limbo(struct work_struct *work) 532 { 533 unsigned long delay = msecs_to_jiffies(CQM_LIMBOCHECK_INTERVAL); 534 int cpu = smp_processor_id(); 535 struct rdt_resource *r; 536 struct rdt_domain *d; 537 538 mutex_lock(&rdtgroup_mutex); 539 540 r = &rdt_resources_all[RDT_RESOURCE_L3]; 541 d = container_of(work, struct rdt_domain, cqm_limbo.work); 542 543 __check_limbo(d, false); 544 545 if (has_busy_rmid(r, d)) 546 schedule_delayed_work_on(cpu, &d->cqm_limbo, delay); 547 548 mutex_unlock(&rdtgroup_mutex); 549 } 550 551 void cqm_setup_limbo_handler(struct rdt_domain *dom, unsigned long delay_ms) 552 { 553 unsigned long delay = msecs_to_jiffies(delay_ms); 554 int cpu; 555 556 cpu = cpumask_any(&dom->cpu_mask); 557 dom->cqm_work_cpu = cpu; 558 559 schedule_delayed_work_on(cpu, &dom->cqm_limbo, delay); 560 } 561 562 void mbm_handle_overflow(struct work_struct *work) 563 { 564 unsigned long delay = msecs_to_jiffies(MBM_OVERFLOW_INTERVAL); 565 struct rdtgroup *prgrp, *crgrp; 566 int cpu = smp_processor_id(); 567 struct list_head *head; 568 struct rdt_resource *r; 569 struct rdt_domain *d; 570 571 mutex_lock(&rdtgroup_mutex); 572 573 if (!static_branch_likely(&rdt_mon_enable_key)) 574 goto out_unlock; 575 576 r = &rdt_resources_all[RDT_RESOURCE_L3]; 577 d = container_of(work, struct rdt_domain, mbm_over.work); 578 579 list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 580 mbm_update(r, d, prgrp->mon.rmid); 581 582 head = &prgrp->mon.crdtgrp_list; 583 list_for_each_entry(crgrp, head, mon.crdtgrp_list) 584 mbm_update(r, d, crgrp->mon.rmid); 585 586 if (is_mba_sc(NULL)) 587 update_mba_bw(prgrp, d); 588 } 589 590 schedule_delayed_work_on(cpu, &d->mbm_over, delay); 591 592 out_unlock: 593 mutex_unlock(&rdtgroup_mutex); 594 } 595 596 void mbm_setup_overflow_handler(struct rdt_domain *dom, unsigned long delay_ms) 597 { 598 unsigned long delay = msecs_to_jiffies(delay_ms); 599 int cpu; 600 601 if (!static_branch_likely(&rdt_mon_enable_key)) 602 return; 603 cpu = cpumask_any(&dom->cpu_mask); 604 dom->mbm_work_cpu = cpu; 605 schedule_delayed_work_on(cpu, &dom->mbm_over, delay); 606 } 607 608 static int dom_data_init(struct rdt_resource *r) 609 { 610 struct rmid_entry *entry = NULL; 611 int i, nr_rmids; 612 613 nr_rmids = r->num_rmid; 614 rmid_ptrs = kcalloc(nr_rmids, sizeof(struct rmid_entry), GFP_KERNEL); 615 if (!rmid_ptrs) 616 return -ENOMEM; 617 618 for (i = 0; i < nr_rmids; i++) { 619 entry = &rmid_ptrs[i]; 620 INIT_LIST_HEAD(&entry->list); 621 622 entry->rmid = i; 623 list_add_tail(&entry->list, &rmid_free_lru); 624 } 625 626 /* 627 * RMID 0 is special and is always allocated. It's used for all 628 * tasks that are not monitored. 629 */ 630 entry = __rmid_entry(0); 631 list_del(&entry->list); 632 633 return 0; 634 } 635 636 static struct mon_evt llc_occupancy_event = { 637 .name = "llc_occupancy", 638 .evtid = QOS_L3_OCCUP_EVENT_ID, 639 }; 640 641 static struct mon_evt mbm_total_event = { 642 .name = "mbm_total_bytes", 643 .evtid = QOS_L3_MBM_TOTAL_EVENT_ID, 644 }; 645 646 static struct mon_evt mbm_local_event = { 647 .name = "mbm_local_bytes", 648 .evtid = QOS_L3_MBM_LOCAL_EVENT_ID, 649 }; 650 651 /* 652 * Initialize the event list for the resource. 653 * 654 * Note that MBM events are also part of RDT_RESOURCE_L3 resource 655 * because as per the SDM the total and local memory bandwidth 656 * are enumerated as part of L3 monitoring. 657 */ 658 static void l3_mon_evt_init(struct rdt_resource *r) 659 { 660 INIT_LIST_HEAD(&r->evt_list); 661 662 if (is_llc_occupancy_enabled()) 663 list_add_tail(&llc_occupancy_event.list, &r->evt_list); 664 if (is_mbm_total_enabled()) 665 list_add_tail(&mbm_total_event.list, &r->evt_list); 666 if (is_mbm_local_enabled()) 667 list_add_tail(&mbm_local_event.list, &r->evt_list); 668 } 669 670 int rdt_get_mon_l3_config(struct rdt_resource *r) 671 { 672 unsigned int mbm_offset = boot_cpu_data.x86_cache_mbm_width_offset; 673 unsigned int cl_size = boot_cpu_data.x86_cache_size; 674 int ret; 675 676 r->mon_scale = boot_cpu_data.x86_cache_occ_scale; 677 r->num_rmid = boot_cpu_data.x86_cache_max_rmid + 1; 678 r->mbm_width = MBM_CNTR_WIDTH_BASE; 679 680 if (mbm_offset > 0 && mbm_offset <= MBM_CNTR_WIDTH_OFFSET_MAX) 681 r->mbm_width += mbm_offset; 682 else if (mbm_offset > MBM_CNTR_WIDTH_OFFSET_MAX) 683 pr_warn("Ignoring impossible MBM counter offset\n"); 684 685 /* 686 * A reasonable upper limit on the max threshold is the number 687 * of lines tagged per RMID if all RMIDs have the same number of 688 * lines tagged in the LLC. 689 * 690 * For a 35MB LLC and 56 RMIDs, this is ~1.8% of the LLC. 691 */ 692 resctrl_cqm_threshold = cl_size * 1024 / r->num_rmid; 693 694 /* h/w works in units of "boot_cpu_data.x86_cache_occ_scale" */ 695 resctrl_cqm_threshold /= r->mon_scale; 696 697 ret = dom_data_init(r); 698 if (ret) 699 return ret; 700 701 l3_mon_evt_init(r); 702 703 r->mon_capable = true; 704 r->mon_enabled = true; 705 706 return 0; 707 } 708 709 void __init intel_rdt_mbm_apply_quirk(void) 710 { 711 int cf_index; 712 713 cf_index = (boot_cpu_data.x86_cache_max_rmid + 1) / 8 - 1; 714 if (cf_index >= ARRAY_SIZE(mbm_cf_table)) { 715 pr_info("No MBM correction factor available\n"); 716 return; 717 } 718 719 mbm_cf_rmidthreshold = mbm_cf_table[cf_index].rmidthreshold; 720 mbm_cf = mbm_cf_table[cf_index].cf; 721 } 722