core.c 24 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * Resource Director Technology(RDT)
 * - Cache Allocation code.
 *
 * Copyright (C) 2016 Intel Corporation
 *
 * Authors:
 *    Fenghua Yu <fenghua.yu@intel.com>
 *    Tony Luck <tony.luck@intel.com>
 *    Vikas Shivappa <vikas.shivappa@intel.com>
 *
 * More information about RDT be found in the Intel (R) x86 Architecture
 * Software Developer Manual June 2016, volume 3, section 17.17.
 */

17
#define pr_fmt(fmt)	"resctrl: " fmt
18 19 20

#include <linux/slab.h>
#include <linux/err.h>
21 22
#include <linux/cacheinfo.h>
#include <linux/cpuhotplug.h>
23

24
#include <asm/intel-family.h>
25 26
#include <asm/resctrl_sched.h>
#include "internal.h"
27

28 29 30
/* Mutex to protect rdtgroup access. */
DEFINE_MUTEX(rdtgroup_mutex);

31
/*
32
 * The cached resctrl_pqr_state is strictly per CPU and can never be
33 34 35 36
 * updated from a remote CPU. Functions which modify the state
 * are called with interrupts disabled and no preemption, which
 * is sufficient for the protection.
 */
37
DEFINE_PER_CPU(struct resctrl_pqr_state, pqr_state);
38

39 40 41 42 43 44
/*
 * Used to store the max resource name width and max resource data width
 * to display the schemata in a tabular format
 */
int max_name_width, max_data_width;

45 46 47 48 49 50
/*
 * Global boolean for rdt_alloc which is true if any
 * resource allocation is enabled.
 */
bool rdt_alloc_capable;

51
static void
52 53
mba_wrmsr_intel(struct rdt_domain *d, struct msr_param *m,
		struct rdt_resource *r);
54 55
static void
cat_wrmsr(struct rdt_domain *d, struct msr_param *m, struct rdt_resource *r);
56 57 58
static void
mba_wrmsr_amd(struct rdt_domain *d, struct msr_param *m,
	      struct rdt_resource *r);
59

60 61
#define domain_init(id) LIST_HEAD_INIT(rdt_resources_all[id].domains)

62
struct rdt_resource rdt_resources_all[] = {
63
	[RDT_RESOURCE_L3] =
64
	{
65
		.rid			= RDT_RESOURCE_L3,
66 67
		.name			= "L3",
		.domains		= domain_init(RDT_RESOURCE_L3),
68
		.msr_base		= MSR_IA32_L3_CBM_BASE,
69
		.msr_update		= cat_wrmsr,
70 71 72 73 74 75
		.cache_level		= 3,
		.cache = {
			.min_cbm_bits	= 1,
			.cbm_idx_mult	= 1,
			.cbm_idx_offset	= 0,
		},
76 77
		.parse_ctrlval		= parse_cbm,
		.format_str		= "%d=%0*x",
78
		.fflags			= RFTYPE_RES_CACHE,
79
	},
80
	[RDT_RESOURCE_L3DATA] =
81
	{
82
		.rid			= RDT_RESOURCE_L3DATA,
83 84
		.name			= "L3DATA",
		.domains		= domain_init(RDT_RESOURCE_L3DATA),
85
		.msr_base		= MSR_IA32_L3_CBM_BASE,
86
		.msr_update		= cat_wrmsr,
87 88 89 90 91 92
		.cache_level		= 3,
		.cache = {
			.min_cbm_bits	= 1,
			.cbm_idx_mult	= 2,
			.cbm_idx_offset	= 0,
		},
93 94
		.parse_ctrlval		= parse_cbm,
		.format_str		= "%d=%0*x",
95
		.fflags			= RFTYPE_RES_CACHE,
96
	},
97
	[RDT_RESOURCE_L3CODE] =
98
	{
99
		.rid			= RDT_RESOURCE_L3CODE,
100 101
		.name			= "L3CODE",
		.domains		= domain_init(RDT_RESOURCE_L3CODE),
102
		.msr_base		= MSR_IA32_L3_CBM_BASE,
103
		.msr_update		= cat_wrmsr,
104 105 106 107 108 109
		.cache_level		= 3,
		.cache = {
			.min_cbm_bits	= 1,
			.cbm_idx_mult	= 2,
			.cbm_idx_offset	= 1,
		},
110 111
		.parse_ctrlval		= parse_cbm,
		.format_str		= "%d=%0*x",
112
		.fflags			= RFTYPE_RES_CACHE,
113
	},
114
	[RDT_RESOURCE_L2] =
115
	{
116
		.rid			= RDT_RESOURCE_L2,
117 118
		.name			= "L2",
		.domains		= domain_init(RDT_RESOURCE_L2),
119
		.msr_base		= MSR_IA32_L2_CBM_BASE,
120
		.msr_update		= cat_wrmsr,
121 122 123 124 125 126
		.cache_level		= 2,
		.cache = {
			.min_cbm_bits	= 1,
			.cbm_idx_mult	= 1,
			.cbm_idx_offset	= 0,
		},
127 128
		.parse_ctrlval		= parse_cbm,
		.format_str		= "%d=%0*x",
129
		.fflags			= RFTYPE_RES_CACHE,
130
	},
131 132 133 134 135
	[RDT_RESOURCE_L2DATA] =
	{
		.rid			= RDT_RESOURCE_L2DATA,
		.name			= "L2DATA",
		.domains		= domain_init(RDT_RESOURCE_L2DATA),
136
		.msr_base		= MSR_IA32_L2_CBM_BASE,
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
		.msr_update		= cat_wrmsr,
		.cache_level		= 2,
		.cache = {
			.min_cbm_bits	= 1,
			.cbm_idx_mult	= 2,
			.cbm_idx_offset	= 0,
		},
		.parse_ctrlval		= parse_cbm,
		.format_str		= "%d=%0*x",
		.fflags			= RFTYPE_RES_CACHE,
	},
	[RDT_RESOURCE_L2CODE] =
	{
		.rid			= RDT_RESOURCE_L2CODE,
		.name			= "L2CODE",
		.domains		= domain_init(RDT_RESOURCE_L2CODE),
153
		.msr_base		= MSR_IA32_L2_CBM_BASE,
154 155 156 157 158 159 160 161 162 163 164
		.msr_update		= cat_wrmsr,
		.cache_level		= 2,
		.cache = {
			.min_cbm_bits	= 1,
			.cbm_idx_mult	= 2,
			.cbm_idx_offset	= 1,
		},
		.parse_ctrlval		= parse_cbm,
		.format_str		= "%d=%0*x",
		.fflags			= RFTYPE_RES_CACHE,
	},
165
	[RDT_RESOURCE_MBA] =
166
	{
167
		.rid			= RDT_RESOURCE_MBA,
168 169 170
		.name			= "MB",
		.domains		= domain_init(RDT_RESOURCE_MBA),
		.cache_level		= 3,
171
		.format_str		= "%d=%*u",
172
		.fflags			= RFTYPE_RES_MB,
173
	},
174 175
};

176
static unsigned int cbm_idx(struct rdt_resource *r, unsigned int closid)
177
{
178
	return closid * r->cache.cbm_idx_mult + r->cache.cbm_idx_offset;
179 180
}

181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
/*
 * cache_alloc_hsw_probe() - Have to probe for Intel haswell server CPUs
 * as they do not have CPUID enumeration support for Cache allocation.
 * The check for Vendor/Family/Model is not enough to guarantee that
 * the MSRs won't #GP fault because only the following SKUs support
 * CAT:
 *	Intel(R) Xeon(R)  CPU E5-2658  v3  @  2.20GHz
 *	Intel(R) Xeon(R)  CPU E5-2648L v3  @  1.80GHz
 *	Intel(R) Xeon(R)  CPU E5-2628L v3  @  2.00GHz
 *	Intel(R) Xeon(R)  CPU E5-2618L v3  @  2.30GHz
 *	Intel(R) Xeon(R)  CPU E5-2608L v3  @  2.00GHz
 *	Intel(R) Xeon(R)  CPU E5-2658A v3  @  2.20GHz
 *
 * Probe by trying to write the first of the L3 cach mask registers
 * and checking that the bits stick. Max CLOSids is always 4 and max cbm length
 * is always 20 on hsw server parts. The minimum cache bitmask length
 * allowed for HSW server is always 2 bits. Hardcode all of them.
 */
199
static inline void cache_alloc_hsw_probe(void)
200
{
201 202
	struct rdt_resource *r  = &rdt_resources_all[RDT_RESOURCE_L3];
	u32 l, h, max_cbm = BIT_MASK(20) - 1;
203

204
	if (wrmsr_safe(MSR_IA32_L3_CBM_BASE, max_cbm, 0))
205
		return;
206 207

	rdmsr(MSR_IA32_L3_CBM_BASE, l, h);
208

209 210 211
	/* If all the bits were set in MSR, return success */
	if (l != max_cbm)
		return;
212

213 214 215 216 217 218 219
	r->num_closid = 4;
	r->default_ctrl = max_cbm;
	r->cache.cbm_len = 20;
	r->cache.shareable_bits = 0xc0000;
	r->cache.min_cbm_bits = 2;
	r->alloc_capable = true;
	r->alloc_enabled = true;
220

221
	rdt_alloc_capable = true;
222 223
}

224 225 226 227 228 229 230 231
bool is_mba_sc(struct rdt_resource *r)
{
	if (!r)
		return rdt_resources_all[RDT_RESOURCE_MBA].membw.mba_sc;

	return r->membw.mba_sc;
}

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
/*
 * rdt_get_mb_table() - get a mapping of bandwidth(b/w) percentage values
 * exposed to user interface and the h/w understandable delay values.
 *
 * The non-linear delay values have the granularity of power of two
 * and also the h/w does not guarantee a curve for configured delay
 * values vs. actual b/w enforced.
 * Hence we need a mapping that is pre calibrated so the user can
 * express the memory b/w as a percentage value.
 */
static inline bool rdt_get_mb_table(struct rdt_resource *r)
{
	/*
	 * There are no Intel SKUs as of now to support non-linear delay.
	 */
	pr_info("MBA b/w map not implemented for cpu:%d, model:%d",
		boot_cpu_data.x86, boot_cpu_data.x86_model);

	return false;
}

253
static bool __get_mem_config_intel(struct rdt_resource *r)
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
{
	union cpuid_0x10_3_eax eax;
	union cpuid_0x10_x_edx edx;
	u32 ebx, ecx;

	cpuid_count(0x00000010, 3, &eax.full, &ebx, &ecx, &edx.full);
	r->num_closid = edx.split.cos_max + 1;
	r->membw.max_delay = eax.split.max_delay + 1;
	r->default_ctrl = MAX_MBA_BW;
	if (ecx & MBA_IS_LINEAR) {
		r->membw.delay_linear = true;
		r->membw.min_bw = MAX_MBA_BW - r->membw.max_delay;
		r->membw.bw_gran = MAX_MBA_BW - r->membw.max_delay;
	} else {
		if (!rdt_get_mb_table(r))
			return false;
	}
	r->data_width = 3;

273 274
	r->alloc_capable = true;
	r->alloc_enabled = true;
275 276 277 278

	return true;
}

279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
static bool __rdt_get_mem_config_amd(struct rdt_resource *r)
{
	union cpuid_0x10_3_eax eax;
	union cpuid_0x10_x_edx edx;
	u32 ebx, ecx;

	cpuid_count(0x80000020, 1, &eax.full, &ebx, &ecx, &edx.full);
	r->num_closid = edx.split.cos_max + 1;
	r->default_ctrl = MAX_MBA_BW_AMD;

	/* AMD does not use delay */
	r->membw.delay_linear = false;

	r->membw.min_bw = 0;
	r->membw.bw_gran = 1;
	/* Max value is 2048, Data width should be 4 in decimal */
	r->data_width = 4;

	r->alloc_capable = true;
	r->alloc_enabled = true;

	return true;
}

303
static void rdt_get_cache_alloc_cfg(int idx, struct rdt_resource *r)
304 305
{
	union cpuid_0x10_1_eax eax;
306
	union cpuid_0x10_x_edx edx;
307 308 309 310
	u32 ebx, ecx;

	cpuid_count(0x00000010, idx, &eax.full, &ebx, &ecx, &edx.full);
	r->num_closid = edx.split.cos_max + 1;
311
	r->cache.cbm_len = eax.split.cbm_len + 1;
312
	r->default_ctrl = BIT_MASK(eax.split.cbm_len + 1) - 1;
313
	r->cache.shareable_bits = ebx & r->default_ctrl;
314
	r->data_width = (r->cache.cbm_len + 3) / 4;
315 316
	r->alloc_capable = true;
	r->alloc_enabled = true;
317 318
}

319
static void rdt_get_cdp_config(int level, int type)
320
{
321
	struct rdt_resource *r_l = &rdt_resources_all[level];
322 323
	struct rdt_resource *r = &rdt_resources_all[type];

324 325 326 327
	r->num_closid = r_l->num_closid / 2;
	r->cache.cbm_len = r_l->cache.cbm_len;
	r->default_ctrl = r_l->default_ctrl;
	r->cache.shareable_bits = r_l->cache.shareable_bits;
328
	r->data_width = (r->cache.cbm_len + 3) / 4;
329
	r->alloc_capable = true;
330 331 332 333
	/*
	 * By default, CDP is disabled. CDP can be enabled by mount parameter
	 * "cdp" during resctrl file system mount time.
	 */
334
	r->alloc_enabled = false;
335 336
}

337 338 339 340 341 342 343 344 345 346 347 348
static void rdt_get_cdp_l3_config(void)
{
	rdt_get_cdp_config(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA);
	rdt_get_cdp_config(RDT_RESOURCE_L3, RDT_RESOURCE_L3CODE);
}

static void rdt_get_cdp_l2_config(void)
{
	rdt_get_cdp_config(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA);
	rdt_get_cdp_config(RDT_RESOURCE_L2, RDT_RESOURCE_L2CODE);
}

349 350 351 352 353 354 355 356 357 358 359 360 361
static int get_cache_id(int cpu, int level)
{
	struct cpu_cacheinfo *ci = get_cpu_cacheinfo(cpu);
	int i;

	for (i = 0; i < ci->num_leaves; i++) {
		if (ci->info_list[i].level == level)
			return ci->info_list[i].id;
	}

	return -1;
}

362 363 364 365 366 367 368 369 370
static void
mba_wrmsr_amd(struct rdt_domain *d, struct msr_param *m, struct rdt_resource *r)
{
	unsigned int i;

	for (i = m->low; i < m->high; i++)
		wrmsrl(r->msr_base + i, d->ctrl_val[i]);
}

371 372 373 374 375
/*
 * Map the memory b/w percentage value to delay values
 * that can be written to QOS_MSRs.
 * There are currently no SKUs which support non linear delay values.
 */
376
u32 delay_bw_map(unsigned long bw, struct rdt_resource *r)
377 378 379 380 381 382 383 384 385
{
	if (r->membw.delay_linear)
		return MAX_MBA_BW - bw;

	pr_warn_once("Non Linear delay-bw map not supported but queried\n");
	return r->default_ctrl;
}

static void
386 387
mba_wrmsr_intel(struct rdt_domain *d, struct msr_param *m,
		struct rdt_resource *r)
388 389 390 391 392 393 394 395
{
	unsigned int i;

	/*  Write the delay values for mba. */
	for (i = m->low; i < m->high; i++)
		wrmsrl(r->msr_base + i, delay_bw_map(d->ctrl_val[i], r));
}

396 397 398 399 400 401 402 403 404
static void
cat_wrmsr(struct rdt_domain *d, struct msr_param *m, struct rdt_resource *r)
{
	unsigned int i;

	for (i = m->low; i < m->high; i++)
		wrmsrl(r->msr_base + cbm_idx(r, i), d->ctrl_val[i]);
}

405 406 407 408 409 410 411 412 413 414 415 416 417
struct rdt_domain *get_domain_from_cpu(int cpu, struct rdt_resource *r)
{
	struct rdt_domain *d;

	list_for_each_entry(d, &r->domains, list) {
		/* Find the domain that contains this CPU */
		if (cpumask_test_cpu(cpu, &d->cpu_mask))
			return d;
	}

	return NULL;
}

418
void rdt_ctrl_update(void *arg)
419
{
420
	struct msr_param *m = arg;
421
	struct rdt_resource *r = m->res;
422
	int cpu = smp_processor_id();
423 424
	struct rdt_domain *d;

425 426 427 428
	d = get_domain_from_cpu(cpu, r);
	if (d) {
		r->msr_update(d, m, r);
		return;
429
	}
430
	pr_warn_once("cpu %d not found in any domain for resource %s\n",
431 432 433 434 435 436 437 438 439 440 441
		     cpu, r->name);
}

/*
 * rdt_find_domain - Find a domain in a resource that matches input resource id
 *
 * Search resource r's domain list to find the resource id. If the resource
 * id is found in a domain, return the domain. Otherwise, if requested by
 * caller, return the first domain whose id is bigger than the input id.
 * The domain list is sorted by id in ascending order.
 */
442 443
struct rdt_domain *rdt_find_domain(struct rdt_resource *r, int id,
				   struct list_head **pos)
444 445 446 447 448
{
	struct rdt_domain *d;
	struct list_head *l;

	if (id < 0)
449
		return ERR_PTR(-ENODEV);
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466

	list_for_each(l, &r->domains) {
		d = list_entry(l, struct rdt_domain, list);
		/* When id is found, return its domain. */
		if (id == d->id)
			return d;
		/* Stop searching when finding id's position in sorted list. */
		if (id < d->id)
			break;
	}

	if (pos)
		*pos = l;

	return NULL;
}

467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
void setup_default_ctrlval(struct rdt_resource *r, u32 *dc, u32 *dm)
{
	int i;

	/*
	 * Initialize the Control MSRs to having no control.
	 * For Cache Allocation: Set all bits in cbm
	 * For Memory Allocation: Set b/w requested to 100%
	 * and the bandwidth in MBps to U32_MAX
	 */
	for (i = 0; i < r->num_closid; i++, dc++, dm++) {
		*dc = r->default_ctrl;
		*dm = MBA_MAX_MBPS;
	}
}

483 484 485
static int domain_setup_ctrlval(struct rdt_resource *r, struct rdt_domain *d)
{
	struct msr_param m;
486
	u32 *dc, *dm;
487 488 489 490 491

	dc = kmalloc_array(r->num_closid, sizeof(*d->ctrl_val), GFP_KERNEL);
	if (!dc)
		return -ENOMEM;

492 493 494 495 496
	dm = kmalloc_array(r->num_closid, sizeof(*d->mbps_val), GFP_KERNEL);
	if (!dm) {
		kfree(dc);
		return -ENOMEM;
	}
497

498 499 500
	d->ctrl_val = dc;
	d->mbps_val = dm;
	setup_default_ctrlval(r, dc, dm);
501 502 503 504 505 506 507

	m.low = 0;
	m.high = r->num_closid;
	r->msr_update(d, &m, r);
	return 0;
}

508 509
static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_domain *d)
{
510 511
	size_t tsize;

512
	if (is_llc_occupancy_enabled()) {
513
		d->rmid_busy_llc = bitmap_zalloc(r->num_rmid, GFP_KERNEL);
514 515
		if (!d->rmid_busy_llc)
			return -ENOMEM;
516
		INIT_DELAYED_WORK(&d->cqm_limbo, cqm_handle_limbo);
517
	}
518 519 520 521
	if (is_mbm_total_enabled()) {
		tsize = sizeof(*d->mbm_total);
		d->mbm_total = kcalloc(r->num_rmid, tsize, GFP_KERNEL);
		if (!d->mbm_total) {
522
			bitmap_free(d->rmid_busy_llc);
523 524 525 526 527 528 529
			return -ENOMEM;
		}
	}
	if (is_mbm_local_enabled()) {
		tsize = sizeof(*d->mbm_local);
		d->mbm_local = kcalloc(r->num_rmid, tsize, GFP_KERNEL);
		if (!d->mbm_local) {
530
			bitmap_free(d->rmid_busy_llc);
531 532 533 534
			kfree(d->mbm_total);
			return -ENOMEM;
		}
	}
535

536 537
	if (is_mbm_enabled()) {
		INIT_DELAYED_WORK(&d->mbm_over, mbm_handle_overflow);
538
		mbm_setup_overflow_handler(d, MBM_OVERFLOW_INTERVAL);
539 540
	}

541 542 543
	return 0;
}

544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
/*
 * domain_add_cpu - Add a cpu to a resource's domain list.
 *
 * If an existing domain in the resource r's domain list matches the cpu's
 * resource id, add the cpu in the domain.
 *
 * Otherwise, a new domain is allocated and inserted into the right position
 * in the domain list sorted by id in ascending order.
 *
 * The order in the domain list is visible to users when we print entries
 * in the schemata file and schemata input is validated to have the same order
 * as this list.
 */
static void domain_add_cpu(int cpu, struct rdt_resource *r)
{
559
	int id = get_cache_id(cpu, r->cache_level);
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
	struct list_head *add_pos = NULL;
	struct rdt_domain *d;

	d = rdt_find_domain(r, id, &add_pos);
	if (IS_ERR(d)) {
		pr_warn("Could't find cache id for cpu %d\n", cpu);
		return;
	}

	if (d) {
		cpumask_set_cpu(cpu, &d->cpu_mask);
		return;
	}

	d = kzalloc_node(sizeof(*d), GFP_KERNEL, cpu_to_node(cpu));
	if (!d)
		return;

	d->id = id;
579
	cpumask_set_cpu(cpu, &d->cpu_mask);
580

581 582
	rdt_domain_reconfigure_cdp(r);

583
	if (r->alloc_capable && domain_setup_ctrlval(r, d)) {
584 585 586 587
		kfree(d);
		return;
	}

588 589 590 591 592
	if (r->mon_capable && domain_setup_mon_state(r, d)) {
		kfree(d);
		return;
	}

593
	list_add_tail(&d->list, add_pos);
594 595 596 597 598 599 600

	/*
	 * If resctrl is mounted, add
	 * per domain monitor data directories.
	 */
	if (static_branch_unlikely(&rdt_mon_enable_key))
		mkdir_mondata_subdir_allrdtgrp(r, d);
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
}

static void domain_remove_cpu(int cpu, struct rdt_resource *r)
{
	int id = get_cache_id(cpu, r->cache_level);
	struct rdt_domain *d;

	d = rdt_find_domain(r, id, NULL);
	if (IS_ERR_OR_NULL(d)) {
		pr_warn("Could't find cache id for cpu %d\n", cpu);
		return;
	}

	cpumask_clear_cpu(cpu, &d->cpu_mask);
	if (cpumask_empty(&d->cpu_mask)) {
616 617 618 619 620 621
		/*
		 * If resctrl is mounted, remove all the
		 * per domain monitor data directories.
		 */
		if (static_branch_unlikely(&rdt_mon_enable_key))
			rmdir_mondata_subdir_allrdtgrp(r, d->id);
622
		list_del(&d->list);
623
		if (r->mon_capable && is_mbm_enabled())
624
			cancel_delayed_work(&d->mbm_over);
625 626 627 628 629 630 631 632 633 634 635 636 637
		if (is_llc_occupancy_enabled() &&  has_busy_rmid(r, d)) {
			/*
			 * When a package is going down, forcefully
			 * decrement rmid->ebusy. There is no way to know
			 * that the L3 was flushed and hence may lead to
			 * incorrect counts in rare scenarios, but leaving
			 * the RMID as busy creates RMID leaks if the
			 * package never comes back.
			 */
			__check_limbo(d, true);
			cancel_delayed_work(&d->cqm_limbo);
		}

638 639 640 641 642 643 644
		/*
		 * rdt_domain "d" is going to be freed below, so clear
		 * its pointer from pseudo_lock_region struct.
		 */
		if (d->plr)
			d->plr->d = NULL;

645
		kfree(d->ctrl_val);
646
		kfree(d->mbps_val);
647
		bitmap_free(d->rmid_busy_llc);
648 649
		kfree(d->mbm_total);
		kfree(d->mbm_local);
650
		kfree(d);
651 652 653 654 655 656 657 658 659 660 661 662 663
		return;
	}

	if (r == &rdt_resources_all[RDT_RESOURCE_L3]) {
		if (is_mbm_enabled() && cpu == d->mbm_work_cpu) {
			cancel_delayed_work(&d->mbm_over);
			mbm_setup_overflow_handler(d, 0);
		}
		if (is_llc_occupancy_enabled() && cpu == d->cqm_work_cpu &&
		    has_busy_rmid(r, d)) {
			cancel_delayed_work(&d->cqm_limbo);
			cqm_setup_limbo_handler(d, 0);
		}
664 665 666
	}
}

667
static void clear_closid_rmid(int cpu)
668
{
669
	struct resctrl_pqr_state *state = this_cpu_ptr(&pqr_state);
Tony Luck's avatar
Tony Luck committed
670

671 672 673 674
	state->default_closid = 0;
	state->default_rmid = 0;
	state->cur_closid = 0;
	state->cur_rmid = 0;
675
	wrmsr(IA32_PQR_ASSOC, 0, 0);
Tony Luck's avatar
Tony Luck committed
676 677
}

678
static int resctrl_online_cpu(unsigned int cpu)
Tony Luck's avatar
Tony Luck committed
679
{
680 681 682
	struct rdt_resource *r;

	mutex_lock(&rdtgroup_mutex);
683
	for_each_capable_rdt_resource(r)
684
		domain_add_cpu(cpu, r);
Tony Luck's avatar
Tony Luck committed
685 686
	/* The cpu is set in default rdtgroup after online. */
	cpumask_set_cpu(cpu, &rdtgroup_default.cpu_mask);
687
	clear_closid_rmid(cpu);
688 689 690 691 692
	mutex_unlock(&rdtgroup_mutex);

	return 0;
}

693 694 695 696 697 698 699 700 701 702 703
static void clear_childcpus(struct rdtgroup *r, unsigned int cpu)
{
	struct rdtgroup *cr;

	list_for_each_entry(cr, &r->mon.crdtgrp_list, mon.crdtgrp_list) {
		if (cpumask_test_and_clear_cpu(cpu, &cr->cpu_mask)) {
			break;
		}
	}
}

704
static int resctrl_offline_cpu(unsigned int cpu)
705
{
Tony Luck's avatar
Tony Luck committed
706
	struct rdtgroup *rdtgrp;
707 708 709
	struct rdt_resource *r;

	mutex_lock(&rdtgroup_mutex);
710
	for_each_capable_rdt_resource(r)
711
		domain_remove_cpu(cpu, r);
Tony Luck's avatar
Tony Luck committed
712
	list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) {
713 714
		if (cpumask_test_and_clear_cpu(cpu, &rdtgrp->cpu_mask)) {
			clear_childcpus(rdtgrp, cpu);
Tony Luck's avatar
Tony Luck committed
715
			break;
716
		}
Tony Luck's avatar
Tony Luck committed
717
	}
718
	clear_closid_rmid(cpu);
719 720 721 722 723
	mutex_unlock(&rdtgroup_mutex);

	return 0;
}

724 725 726 727 728 729 730 731 732
/*
 * Choose a width for the resource name and resource data based on the
 * resource that has widest name and cbm.
 */
static __init void rdt_init_padding(void)
{
	struct rdt_resource *r;
	int cl;

733
	for_each_alloc_capable_rdt_resource(r) {
734 735 736 737 738 739 740 741 742
		cl = strlen(r->name);
		if (cl > max_name_width)
			max_name_width = cl;

		if (r->data_width > max_data_width)
			max_data_width = r->data_width;
	}
}

743 744 745 746 747 748 749
enum {
	RDT_FLAG_CMT,
	RDT_FLAG_MBM_TOTAL,
	RDT_FLAG_MBM_LOCAL,
	RDT_FLAG_L3_CAT,
	RDT_FLAG_L3_CDP,
	RDT_FLAG_L2_CAT,
750
	RDT_FLAG_L2_CDP,
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
	RDT_FLAG_MBA,
};

#define RDT_OPT(idx, n, f)	\
[idx] = {			\
	.name = n,		\
	.flag = f		\
}

struct rdt_options {
	char	*name;
	int	flag;
	bool	force_off, force_on;
};

static struct rdt_options rdt_options[]  __initdata = {
	RDT_OPT(RDT_FLAG_CMT,	    "cmt",	X86_FEATURE_CQM_OCCUP_LLC),
	RDT_OPT(RDT_FLAG_MBM_TOTAL, "mbmtotal", X86_FEATURE_CQM_MBM_TOTAL),
	RDT_OPT(RDT_FLAG_MBM_LOCAL, "mbmlocal", X86_FEATURE_CQM_MBM_LOCAL),
	RDT_OPT(RDT_FLAG_L3_CAT,    "l3cat",	X86_FEATURE_CAT_L3),
	RDT_OPT(RDT_FLAG_L3_CDP,    "l3cdp",	X86_FEATURE_CDP_L3),
	RDT_OPT(RDT_FLAG_L2_CAT,    "l2cat",	X86_FEATURE_CAT_L2),
773
	RDT_OPT(RDT_FLAG_L2_CDP,    "l2cdp",	X86_FEATURE_CDP_L2),
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
	RDT_OPT(RDT_FLAG_MBA,	    "mba",	X86_FEATURE_MBA),
};
#define NUM_RDT_OPTIONS ARRAY_SIZE(rdt_options)

static int __init set_rdt_options(char *str)
{
	struct rdt_options *o;
	bool force_off;
	char *tok;

	if (*str == '=')
		str++;
	while ((tok = strsep(&str, ",")) != NULL) {
		force_off = *tok == '!';
		if (force_off)
			tok++;
		for (o = rdt_options; o < &rdt_options[NUM_RDT_OPTIONS]; o++) {
			if (strcmp(tok, o->name) == 0) {
				if (force_off)
					o->force_off = true;
				else
					o->force_on = true;
				break;
			}
		}
	}
	return 1;
}
__setup("rdt", set_rdt_options);

static bool __init rdt_cpu_has(int flag)
{
	bool ret = boot_cpu_has(flag);
	struct rdt_options *o;

	if (!ret)
		return ret;

	for (o = rdt_options; o < &rdt_options[NUM_RDT_OPTIONS]; o++) {
		if (flag == o->flag) {
			if (o->force_off)
				ret = false;
			if (o->force_on)
				ret = true;
			break;
		}
	}
	return ret;
}

824 825
static __init bool get_mem_config(void)
{
826 827 828 829 830 831 832
	if (!rdt_cpu_has(X86_FEATURE_MBA))
		return false;

	if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
		return __get_mem_config_intel(&rdt_resources_all[RDT_RESOURCE_MBA]);
	else if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
		return __rdt_get_mem_config_amd(&rdt_resources_all[RDT_RESOURCE_MBA]);
833 834 835 836

	return false;
}

837
static __init bool get_rdt_alloc_resources(void)
838 839 840
{
	bool ret = false;

841
	if (rdt_alloc_capable)
842 843 844 845 846
		return true;

	if (!boot_cpu_has(X86_FEATURE_RDT_A))
		return false;

847
	if (rdt_cpu_has(X86_FEATURE_CAT_L3)) {
848
		rdt_get_cache_alloc_cfg(1, &rdt_resources_all[RDT_RESOURCE_L3]);
849 850
		if (rdt_cpu_has(X86_FEATURE_CDP_L3))
			rdt_get_cdp_l3_config();
851 852
		ret = true;
	}
853
	if (rdt_cpu_has(X86_FEATURE_CAT_L2)) {
854
		/* CPUID 0x10.2 fields are same format at 0x10.1 */
855
		rdt_get_cache_alloc_cfg(2, &rdt_resources_all[RDT_RESOURCE_L2]);
856 857
		if (rdt_cpu_has(X86_FEATURE_CDP_L2))
			rdt_get_cdp_l2_config();
858 859
		ret = true;
	}
860

861 862 863
	if (get_mem_config())
		ret = true;

864 865 866
	return ret;
}

867 868
static __init bool get_rdt_mon_resources(void)
{
869
	if (rdt_cpu_has(X86_FEATURE_CQM_OCCUP_LLC))
870
		rdt_mon_features |= (1 << QOS_L3_OCCUP_EVENT_ID);
871
	if (rdt_cpu_has(X86_FEATURE_CQM_MBM_TOTAL))
872
		rdt_mon_features |= (1 << QOS_L3_MBM_TOTAL_EVENT_ID);
873
	if (rdt_cpu_has(X86_FEATURE_CQM_MBM_LOCAL))
874 875 876 877 878 879 880 881
		rdt_mon_features |= (1 << QOS_L3_MBM_LOCAL_EVENT_ID);

	if (!rdt_mon_features)
		return false;

	return !rdt_get_mon_l3_config(&rdt_resources_all[RDT_RESOURCE_L3]);
}

882
static __init void __check_quirks_intel(void)
883 884 885
{
	switch (boot_cpu_data.x86_model) {
	case INTEL_FAM6_HASWELL_X:
886 887
		if (!rdt_options[RDT_FLAG_L3_CAT].force_off)
			cache_alloc_hsw_probe();
888
		break;
889
	case INTEL_FAM6_SKYLAKE_X:
890
		if (boot_cpu_data.x86_stepping <= 4)
891
			set_rdt_options("!cmt,!mbmtotal,!mbmlocal,!l3cat");
892 893
		else
			set_rdt_options("!l3cat");
894 895 896
	}
}

897 898 899 900 901 902
static __init void check_quirks(void)
{
	if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
		__check_quirks_intel();
}

903 904 905 906 907 908 909 910
static __init bool get_rdt_resources(void)
{
	rdt_alloc_capable = get_rdt_alloc_resources();
	rdt_mon_capable = get_rdt_mon_resources();

	return (rdt_mon_capable || rdt_alloc_capable);
}

911 912 913 914 915
static __init void rdt_init_res_defs_intel(void)
{
	struct rdt_resource *r;

	for_each_rdt_resource(r) {
916 917 918 919 920 921 922 923
		if (r->rid == RDT_RESOURCE_L3 ||
		    r->rid == RDT_RESOURCE_L3DATA ||
		    r->rid == RDT_RESOURCE_L3CODE ||
		    r->rid == RDT_RESOURCE_L2 ||
		    r->rid == RDT_RESOURCE_L2DATA ||
		    r->rid == RDT_RESOURCE_L2CODE)
			r->cbm_validate = cbm_validate_intel;
		else if (r->rid == RDT_RESOURCE_MBA) {
924 925 926 927 928 929 930
			r->msr_base = MSR_IA32_MBA_THRTL_BASE;
			r->msr_update = mba_wrmsr_intel;
			r->parse_ctrlval = parse_bw_intel;
		}
	}
}

931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950
static __init void rdt_init_res_defs_amd(void)
{
	struct rdt_resource *r;

	for_each_rdt_resource(r) {
		if (r->rid == RDT_RESOURCE_L3 ||
		    r->rid == RDT_RESOURCE_L3DATA ||
		    r->rid == RDT_RESOURCE_L3CODE ||
		    r->rid == RDT_RESOURCE_L2 ||
		    r->rid == RDT_RESOURCE_L2DATA ||
		    r->rid == RDT_RESOURCE_L2CODE)
			r->cbm_validate = cbm_validate_amd;
		else if (r->rid == RDT_RESOURCE_MBA) {
			r->msr_base = MSR_IA32_MBA_BW_BASE;
			r->msr_update = mba_wrmsr_amd;
			r->parse_ctrlval = parse_bw_amd;
		}
	}
}

951 952 953 954
static __init void rdt_init_res_defs(void)
{
	if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
		rdt_init_res_defs_intel();
955 956
	else if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
		rdt_init_res_defs_amd();
957 958
}

959 960
static enum cpuhp_state rdt_online;

961
static int __init resctrl_late_init(void)
962
{
963
	struct rdt_resource *r;
964
	int state, ret;
965

966 967 968 969 970 971
	/*
	 * Initialize functions(or definitions) that are different
	 * between vendors here.
	 */
	rdt_init_res_defs();

972 973
	check_quirks();

974 975 976
	if (!get_rdt_resources())
		return -ENODEV;

977 978
	rdt_init_padding();

979
	state = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN,
980 981
				  "x86/resctrl/cat:online:",
				  resctrl_online_cpu, resctrl_offline_cpu);
982 983 984
	if (state < 0)
		return state;

985 986 987 988 989
	ret = rdtgroup_init();
	if (ret) {
		cpuhp_remove_state(state);
		return ret;
	}
990
	rdt_online = state;
991

992
	for_each_alloc_capable_rdt_resource(r)
993
		pr_info("%s allocation detected\n", r->name);
994

995
	for_each_mon_capable_rdt_resource(r)
996
		pr_info("%s monitoring detected\n", r->name);
997

998 999 1000
	return 0;
}

1001
late_initcall(resctrl_late_init);
1002

1003
static void __exit resctrl_exit(void)
1004 1005 1006 1007 1008
{
	cpuhp_remove_state(rdt_online);
	rdtgroup_exit();
}

1009
__exitcall(resctrl_exit);