xref: /openbmc/linux/arch/x86/kernel/cpu/resctrl/monitor.c (revision 31e67366)
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[] __initdata = {
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 int __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 		rr->val = tval;
296 		return -EINVAL;
297 	}
298 	switch (rr->evtid) {
299 	case QOS_L3_OCCUP_EVENT_ID:
300 		rr->val += tval;
301 		return 0;
302 	case QOS_L3_MBM_TOTAL_EVENT_ID:
303 		m = &rr->d->mbm_total[rmid];
304 		break;
305 	case QOS_L3_MBM_LOCAL_EVENT_ID:
306 		m = &rr->d->mbm_local[rmid];
307 		break;
308 	default:
309 		/*
310 		 * Code would never reach here because
311 		 * an invalid event id would fail the __rmid_read.
312 		 */
313 		return -EINVAL;
314 	}
315 
316 	if (rr->first) {
317 		memset(m, 0, sizeof(struct mbm_state));
318 		m->prev_bw_msr = m->prev_msr = tval;
319 		return 0;
320 	}
321 
322 	chunks = mbm_overflow_count(m->prev_msr, tval, rr->r->mbm_width);
323 	m->chunks += chunks;
324 	m->prev_msr = tval;
325 
326 	rr->val += get_corrected_mbm_count(rmid, m->chunks);
327 
328 	return 0;
329 }
330 
331 /*
332  * Supporting function to calculate the memory bandwidth
333  * and delta bandwidth in MBps.
334  */
335 static void mbm_bw_count(u32 rmid, struct rmid_read *rr)
336 {
337 	struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_L3];
338 	struct mbm_state *m = &rr->d->mbm_local[rmid];
339 	u64 tval, cur_bw, chunks;
340 
341 	tval = __rmid_read(rmid, rr->evtid);
342 	if (tval & (RMID_VAL_ERROR | RMID_VAL_UNAVAIL))
343 		return;
344 
345 	chunks = mbm_overflow_count(m->prev_bw_msr, tval, rr->r->mbm_width);
346 	cur_bw = (get_corrected_mbm_count(rmid, chunks) * r->mon_scale) >> 20;
347 
348 	if (m->delta_comp)
349 		m->delta_bw = abs(cur_bw - m->prev_bw);
350 	m->delta_comp = false;
351 	m->prev_bw = cur_bw;
352 	m->prev_bw_msr = tval;
353 }
354 
355 /*
356  * This is called via IPI to read the CQM/MBM counters
357  * on a domain.
358  */
359 void mon_event_count(void *info)
360 {
361 	struct rdtgroup *rdtgrp, *entry;
362 	struct rmid_read *rr = info;
363 	struct list_head *head;
364 
365 	rdtgrp = rr->rgrp;
366 
367 	if (__mon_event_count(rdtgrp->mon.rmid, rr))
368 		return;
369 
370 	/*
371 	 * For Ctrl groups read data from child monitor groups.
372 	 */
373 	head = &rdtgrp->mon.crdtgrp_list;
374 
375 	if (rdtgrp->type == RDTCTRL_GROUP) {
376 		list_for_each_entry(entry, head, mon.crdtgrp_list) {
377 			if (__mon_event_count(entry->mon.rmid, rr))
378 				return;
379 		}
380 	}
381 }
382 
383 /*
384  * Feedback loop for MBA software controller (mba_sc)
385  *
386  * mba_sc is a feedback loop where we periodically read MBM counters and
387  * adjust the bandwidth percentage values via the IA32_MBA_THRTL_MSRs so
388  * that:
389  *
390  *   current bandwdith(cur_bw) < user specified bandwidth(user_bw)
391  *
392  * This uses the MBM counters to measure the bandwidth and MBA throttle
393  * MSRs to control the bandwidth for a particular rdtgrp. It builds on the
394  * fact that resctrl rdtgroups have both monitoring and control.
395  *
396  * The frequency of the checks is 1s and we just tag along the MBM overflow
397  * timer. Having 1s interval makes the calculation of bandwidth simpler.
398  *
399  * Although MBA's goal is to restrict the bandwidth to a maximum, there may
400  * be a need to increase the bandwidth to avoid uncecessarily restricting
401  * the L2 <-> L3 traffic.
402  *
403  * Since MBA controls the L2 external bandwidth where as MBM measures the
404  * L3 external bandwidth the following sequence could lead to such a
405  * situation.
406  *
407  * Consider an rdtgroup which had high L3 <-> memory traffic in initial
408  * phases -> mba_sc kicks in and reduced bandwidth percentage values -> but
409  * after some time rdtgroup has mostly L2 <-> L3 traffic.
410  *
411  * In this case we may restrict the rdtgroup's L2 <-> L3 traffic as its
412  * throttle MSRs already have low percentage values.  To avoid
413  * unnecessarily restricting such rdtgroups, we also increase the bandwidth.
414  */
415 static void update_mba_bw(struct rdtgroup *rgrp, struct rdt_domain *dom_mbm)
416 {
417 	u32 closid, rmid, cur_msr, cur_msr_val, new_msr_val;
418 	struct mbm_state *pmbm_data, *cmbm_data;
419 	u32 cur_bw, delta_bw, user_bw;
420 	struct rdt_resource *r_mba;
421 	struct rdt_domain *dom_mba;
422 	struct list_head *head;
423 	struct rdtgroup *entry;
424 
425 	if (!is_mbm_local_enabled())
426 		return;
427 
428 	r_mba = &rdt_resources_all[RDT_RESOURCE_MBA];
429 	closid = rgrp->closid;
430 	rmid = rgrp->mon.rmid;
431 	pmbm_data = &dom_mbm->mbm_local[rmid];
432 
433 	dom_mba = get_domain_from_cpu(smp_processor_id(), r_mba);
434 	if (!dom_mba) {
435 		pr_warn_once("Failure to get domain for MBA update\n");
436 		return;
437 	}
438 
439 	cur_bw = pmbm_data->prev_bw;
440 	user_bw = dom_mba->mbps_val[closid];
441 	delta_bw = pmbm_data->delta_bw;
442 	cur_msr_val = dom_mba->ctrl_val[closid];
443 
444 	/*
445 	 * For Ctrl groups read data from child monitor groups.
446 	 */
447 	head = &rgrp->mon.crdtgrp_list;
448 	list_for_each_entry(entry, head, mon.crdtgrp_list) {
449 		cmbm_data = &dom_mbm->mbm_local[entry->mon.rmid];
450 		cur_bw += cmbm_data->prev_bw;
451 		delta_bw += cmbm_data->delta_bw;
452 	}
453 
454 	/*
455 	 * Scale up/down the bandwidth linearly for the ctrl group.  The
456 	 * bandwidth step is the bandwidth granularity specified by the
457 	 * hardware.
458 	 *
459 	 * The delta_bw is used when increasing the bandwidth so that we
460 	 * dont alternately increase and decrease the control values
461 	 * continuously.
462 	 *
463 	 * For ex: consider cur_bw = 90MBps, user_bw = 100MBps and if
464 	 * bandwidth step is 20MBps(> user_bw - cur_bw), we would keep
465 	 * switching between 90 and 110 continuously if we only check
466 	 * cur_bw < user_bw.
467 	 */
468 	if (cur_msr_val > r_mba->membw.min_bw && user_bw < cur_bw) {
469 		new_msr_val = cur_msr_val - r_mba->membw.bw_gran;
470 	} else if (cur_msr_val < MAX_MBA_BW &&
471 		   (user_bw > (cur_bw + delta_bw))) {
472 		new_msr_val = cur_msr_val + r_mba->membw.bw_gran;
473 	} else {
474 		return;
475 	}
476 
477 	cur_msr = r_mba->msr_base + closid;
478 	wrmsrl(cur_msr, delay_bw_map(new_msr_val, r_mba));
479 	dom_mba->ctrl_val[closid] = new_msr_val;
480 
481 	/*
482 	 * Delta values are updated dynamically package wise for each
483 	 * rdtgrp everytime the throttle MSR changes value.
484 	 *
485 	 * This is because (1)the increase in bandwidth is not perfectly
486 	 * linear and only "approximately" linear even when the hardware
487 	 * says it is linear.(2)Also since MBA is a core specific
488 	 * mechanism, the delta values vary based on number of cores used
489 	 * by the rdtgrp.
490 	 */
491 	pmbm_data->delta_comp = true;
492 	list_for_each_entry(entry, head, mon.crdtgrp_list) {
493 		cmbm_data = &dom_mbm->mbm_local[entry->mon.rmid];
494 		cmbm_data->delta_comp = true;
495 	}
496 }
497 
498 static void mbm_update(struct rdt_resource *r, struct rdt_domain *d, int rmid)
499 {
500 	struct rmid_read rr;
501 
502 	rr.first = false;
503 	rr.r = r;
504 	rr.d = d;
505 
506 	/*
507 	 * This is protected from concurrent reads from user
508 	 * as both the user and we hold the global mutex.
509 	 */
510 	if (is_mbm_total_enabled()) {
511 		rr.evtid = QOS_L3_MBM_TOTAL_EVENT_ID;
512 		__mon_event_count(rmid, &rr);
513 	}
514 	if (is_mbm_local_enabled()) {
515 		rr.evtid = QOS_L3_MBM_LOCAL_EVENT_ID;
516 		__mon_event_count(rmid, &rr);
517 
518 		/*
519 		 * Call the MBA software controller only for the
520 		 * control groups and when user has enabled
521 		 * the software controller explicitly.
522 		 */
523 		if (is_mba_sc(NULL))
524 			mbm_bw_count(rmid, &rr);
525 	}
526 }
527 
528 /*
529  * Handler to scan the limbo list and move the RMIDs
530  * to free list whose occupancy < threshold_occupancy.
531  */
532 void cqm_handle_limbo(struct work_struct *work)
533 {
534 	unsigned long delay = msecs_to_jiffies(CQM_LIMBOCHECK_INTERVAL);
535 	int cpu = smp_processor_id();
536 	struct rdt_resource *r;
537 	struct rdt_domain *d;
538 
539 	mutex_lock(&rdtgroup_mutex);
540 
541 	r = &rdt_resources_all[RDT_RESOURCE_L3];
542 	d = container_of(work, struct rdt_domain, cqm_limbo.work);
543 
544 	__check_limbo(d, false);
545 
546 	if (has_busy_rmid(r, d))
547 		schedule_delayed_work_on(cpu, &d->cqm_limbo, delay);
548 
549 	mutex_unlock(&rdtgroup_mutex);
550 }
551 
552 void cqm_setup_limbo_handler(struct rdt_domain *dom, unsigned long delay_ms)
553 {
554 	unsigned long delay = msecs_to_jiffies(delay_ms);
555 	int cpu;
556 
557 	cpu = cpumask_any(&dom->cpu_mask);
558 	dom->cqm_work_cpu = cpu;
559 
560 	schedule_delayed_work_on(cpu, &dom->cqm_limbo, delay);
561 }
562 
563 void mbm_handle_overflow(struct work_struct *work)
564 {
565 	unsigned long delay = msecs_to_jiffies(MBM_OVERFLOW_INTERVAL);
566 	struct rdtgroup *prgrp, *crgrp;
567 	int cpu = smp_processor_id();
568 	struct list_head *head;
569 	struct rdt_resource *r;
570 	struct rdt_domain *d;
571 
572 	mutex_lock(&rdtgroup_mutex);
573 
574 	if (!static_branch_likely(&rdt_mon_enable_key))
575 		goto out_unlock;
576 
577 	r = &rdt_resources_all[RDT_RESOURCE_L3];
578 	d = container_of(work, struct rdt_domain, mbm_over.work);
579 
580 	list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) {
581 		mbm_update(r, d, prgrp->mon.rmid);
582 
583 		head = &prgrp->mon.crdtgrp_list;
584 		list_for_each_entry(crgrp, head, mon.crdtgrp_list)
585 			mbm_update(r, d, crgrp->mon.rmid);
586 
587 		if (is_mba_sc(NULL))
588 			update_mba_bw(prgrp, d);
589 	}
590 
591 	schedule_delayed_work_on(cpu, &d->mbm_over, delay);
592 
593 out_unlock:
594 	mutex_unlock(&rdtgroup_mutex);
595 }
596 
597 void mbm_setup_overflow_handler(struct rdt_domain *dom, unsigned long delay_ms)
598 {
599 	unsigned long delay = msecs_to_jiffies(delay_ms);
600 	int cpu;
601 
602 	if (!static_branch_likely(&rdt_mon_enable_key))
603 		return;
604 	cpu = cpumask_any(&dom->cpu_mask);
605 	dom->mbm_work_cpu = cpu;
606 	schedule_delayed_work_on(cpu, &dom->mbm_over, delay);
607 }
608 
609 static int dom_data_init(struct rdt_resource *r)
610 {
611 	struct rmid_entry *entry = NULL;
612 	int i, nr_rmids;
613 
614 	nr_rmids = r->num_rmid;
615 	rmid_ptrs = kcalloc(nr_rmids, sizeof(struct rmid_entry), GFP_KERNEL);
616 	if (!rmid_ptrs)
617 		return -ENOMEM;
618 
619 	for (i = 0; i < nr_rmids; i++) {
620 		entry = &rmid_ptrs[i];
621 		INIT_LIST_HEAD(&entry->list);
622 
623 		entry->rmid = i;
624 		list_add_tail(&entry->list, &rmid_free_lru);
625 	}
626 
627 	/*
628 	 * RMID 0 is special and is always allocated. It's used for all
629 	 * tasks that are not monitored.
630 	 */
631 	entry = __rmid_entry(0);
632 	list_del(&entry->list);
633 
634 	return 0;
635 }
636 
637 static struct mon_evt llc_occupancy_event = {
638 	.name		= "llc_occupancy",
639 	.evtid		= QOS_L3_OCCUP_EVENT_ID,
640 };
641 
642 static struct mon_evt mbm_total_event = {
643 	.name		= "mbm_total_bytes",
644 	.evtid		= QOS_L3_MBM_TOTAL_EVENT_ID,
645 };
646 
647 static struct mon_evt mbm_local_event = {
648 	.name		= "mbm_local_bytes",
649 	.evtid		= QOS_L3_MBM_LOCAL_EVENT_ID,
650 };
651 
652 /*
653  * Initialize the event list for the resource.
654  *
655  * Note that MBM events are also part of RDT_RESOURCE_L3 resource
656  * because as per the SDM the total and local memory bandwidth
657  * are enumerated as part of L3 monitoring.
658  */
659 static void l3_mon_evt_init(struct rdt_resource *r)
660 {
661 	INIT_LIST_HEAD(&r->evt_list);
662 
663 	if (is_llc_occupancy_enabled())
664 		list_add_tail(&llc_occupancy_event.list, &r->evt_list);
665 	if (is_mbm_total_enabled())
666 		list_add_tail(&mbm_total_event.list, &r->evt_list);
667 	if (is_mbm_local_enabled())
668 		list_add_tail(&mbm_local_event.list, &r->evt_list);
669 }
670 
671 int rdt_get_mon_l3_config(struct rdt_resource *r)
672 {
673 	unsigned int mbm_offset = boot_cpu_data.x86_cache_mbm_width_offset;
674 	unsigned int cl_size = boot_cpu_data.x86_cache_size;
675 	int ret;
676 
677 	r->mon_scale = boot_cpu_data.x86_cache_occ_scale;
678 	r->num_rmid = boot_cpu_data.x86_cache_max_rmid + 1;
679 	r->mbm_width = MBM_CNTR_WIDTH_BASE;
680 
681 	if (mbm_offset > 0 && mbm_offset <= MBM_CNTR_WIDTH_OFFSET_MAX)
682 		r->mbm_width += mbm_offset;
683 	else if (mbm_offset > MBM_CNTR_WIDTH_OFFSET_MAX)
684 		pr_warn("Ignoring impossible MBM counter offset\n");
685 
686 	/*
687 	 * A reasonable upper limit on the max threshold is the number
688 	 * of lines tagged per RMID if all RMIDs have the same number of
689 	 * lines tagged in the LLC.
690 	 *
691 	 * For a 35MB LLC and 56 RMIDs, this is ~1.8% of the LLC.
692 	 */
693 	resctrl_cqm_threshold = cl_size * 1024 / r->num_rmid;
694 
695 	/* h/w works in units of "boot_cpu_data.x86_cache_occ_scale" */
696 	resctrl_cqm_threshold /= r->mon_scale;
697 
698 	ret = dom_data_init(r);
699 	if (ret)
700 		return ret;
701 
702 	l3_mon_evt_init(r);
703 
704 	r->mon_capable = true;
705 	r->mon_enabled = true;
706 
707 	return 0;
708 }
709 
710 void __init intel_rdt_mbm_apply_quirk(void)
711 {
712 	int cf_index;
713 
714 	cf_index = (boot_cpu_data.x86_cache_max_rmid + 1) / 8 - 1;
715 	if (cf_index >= ARRAY_SIZE(mbm_cf_table)) {
716 		pr_info("No MBM correction factor available\n");
717 		return;
718 	}
719 
720 	mbm_cf_rmidthreshold = mbm_cf_table[cf_index].rmidthreshold;
721 	mbm_cf = mbm_cf_table[cf_index].cf;
722 }
723