1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Resource Director Technology(RDT)
4 * - Cache Allocation code.
5 *
6 * Copyright (C) 2016 Intel Corporation
7 *
8 * Authors:
9 * Fenghua Yu <fenghua.yu@intel.com>
10 * Tony Luck <tony.luck@intel.com>
11 *
12 * More information about RDT be found in the Intel (R) x86 Architecture
13 * Software Developer Manual June 2016, volume 3, section 17.17.
14 */
15
16#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18#include <linux/cpu.h>
19#include <linux/kernfs.h>
20#include <linux/seq_file.h>
21#include <linux/slab.h>
22#include <linux/tick.h>
23
24#include "internal.h"
25
26struct rdt_parse_data {
27 u32 closid;
28 enum rdtgrp_mode mode;
29 char *buf;
30};
31
32typedef int (ctrlval_parser_t)(struct rdt_parse_data *data,
33 struct resctrl_schema *s,
34 struct rdt_ctrl_domain *d);
35
36/*
37 * Check whether MBA bandwidth percentage value is correct. The value is
38 * checked against the minimum and max bandwidth values specified by the
39 * hardware. The allocated bandwidth percentage is rounded to the next
40 * control step available on the hardware.
41 */
42static bool bw_validate(char *buf, u32 *data, struct rdt_resource *r)
43{
44 int ret;
45 u32 bw;
46
47 /*
48 * Only linear delay values is supported for current Intel SKUs.
49 */
50 if (!r->membw.delay_linear && r->membw.arch_needs_linear) {
51 rdt_last_cmd_puts(s: "No support for non-linear MB domains\n");
52 return false;
53 }
54
55 ret = kstrtou32(s: buf, base: 10, res: &bw);
56 if (ret) {
57 rdt_last_cmd_printf(fmt: "Invalid MB value %s\n", buf);
58 return false;
59 }
60
61 /* Nothing else to do if software controller is enabled. */
62 if (is_mba_sc(r)) {
63 *data = bw;
64 return true;
65 }
66
67 if (bw < r->membw.min_bw || bw > r->membw.max_bw) {
68 rdt_last_cmd_printf(fmt: "MB value %u out of range [%d,%d]\n",
69 bw, r->membw.min_bw, r->membw.max_bw);
70 return false;
71 }
72
73 *data = roundup(bw, (unsigned long)r->membw.bw_gran);
74 return true;
75}
76
77static int parse_bw(struct rdt_parse_data *data, struct resctrl_schema *s,
78 struct rdt_ctrl_domain *d)
79{
80 struct resctrl_staged_config *cfg;
81 struct rdt_resource *r = s->res;
82 u32 closid = data->closid;
83 u32 bw_val;
84
85 cfg = &d->staged_config[s->conf_type];
86 if (cfg->have_new_ctrl) {
87 rdt_last_cmd_printf(fmt: "Duplicate domain %d\n", d->hdr.id);
88 return -EINVAL;
89 }
90
91 if (!bw_validate(buf: data->buf, data: &bw_val, r))
92 return -EINVAL;
93
94 if (is_mba_sc(r)) {
95 d->mbps_val[closid] = bw_val;
96 return 0;
97 }
98
99 cfg->new_ctrl = bw_val;
100 cfg->have_new_ctrl = true;
101
102 return 0;
103}
104
105/*
106 * Check whether a cache bit mask is valid.
107 * On Intel CPUs, non-contiguous 1s value support is indicated by CPUID:
108 * - CPUID.0x10.1:ECX[3]: L3 non-contiguous 1s value supported if 1
109 * - CPUID.0x10.2:ECX[3]: L2 non-contiguous 1s value supported if 1
110 *
111 * Haswell does not support a non-contiguous 1s value and additionally
112 * requires at least two bits set.
113 * AMD allows non-contiguous bitmasks.
114 */
115static bool cbm_validate(char *buf, u32 *data, struct rdt_resource *r)
116{
117 u32 supported_bits = BIT_MASK(r->cache.cbm_len) - 1;
118 unsigned int cbm_len = r->cache.cbm_len;
119 unsigned long first_bit, zero_bit, val;
120 int ret;
121
122 ret = kstrtoul(s: buf, base: 16, res: &val);
123 if (ret) {
124 rdt_last_cmd_printf(fmt: "Non-hex character in the mask %s\n", buf);
125 return false;
126 }
127
128 if ((r->cache.min_cbm_bits > 0 && val == 0) || val > supported_bits) {
129 rdt_last_cmd_puts(s: "Mask out of range\n");
130 return false;
131 }
132
133 first_bit = find_first_bit(addr: &val, size: cbm_len);
134 zero_bit = find_next_zero_bit(addr: &val, size: cbm_len, offset: first_bit);
135
136 /* Are non-contiguous bitmasks allowed? */
137 if (!r->cache.arch_has_sparse_bitmasks &&
138 (find_next_bit(addr: &val, size: cbm_len, offset: zero_bit) < cbm_len)) {
139 rdt_last_cmd_printf(fmt: "The mask %lx has non-consecutive 1-bits\n", val);
140 return false;
141 }
142
143 if ((zero_bit - first_bit) < r->cache.min_cbm_bits) {
144 rdt_last_cmd_printf(fmt: "Need at least %d bits in the mask\n",
145 r->cache.min_cbm_bits);
146 return false;
147 }
148
149 *data = val;
150 return true;
151}
152
153/*
154 * Read one cache bit mask (hex). Check that it is valid for the current
155 * resource type.
156 */
157static int parse_cbm(struct rdt_parse_data *data, struct resctrl_schema *s,
158 struct rdt_ctrl_domain *d)
159{
160 enum rdtgrp_mode mode = data->mode;
161 struct resctrl_staged_config *cfg;
162 struct rdt_resource *r = s->res;
163 u32 closid = data->closid;
164 u32 cbm_val;
165
166 cfg = &d->staged_config[s->conf_type];
167 if (cfg->have_new_ctrl) {
168 rdt_last_cmd_printf(fmt: "Duplicate domain %d\n", d->hdr.id);
169 return -EINVAL;
170 }
171
172 /*
173 * Cannot set up more than one pseudo-locked region in a cache
174 * hierarchy.
175 */
176 if (mode == RDT_MODE_PSEUDO_LOCKSETUP &&
177 rdtgroup_pseudo_locked_in_hierarchy(d)) {
178 rdt_last_cmd_puts(s: "Pseudo-locked region in hierarchy\n");
179 return -EINVAL;
180 }
181
182 if (!cbm_validate(buf: data->buf, data: &cbm_val, r))
183 return -EINVAL;
184
185 if ((mode == RDT_MODE_EXCLUSIVE || mode == RDT_MODE_SHAREABLE) &&
186 rdtgroup_cbm_overlaps_pseudo_locked(d, cbm: cbm_val)) {
187 rdt_last_cmd_puts(s: "CBM overlaps with pseudo-locked region\n");
188 return -EINVAL;
189 }
190
191 /*
192 * The CBM may not overlap with the CBM of another closid if
193 * either is exclusive.
194 */
195 if (rdtgroup_cbm_overlaps(s, d, cbm: cbm_val, closid, exclusive: true)) {
196 rdt_last_cmd_puts(s: "Overlaps with exclusive group\n");
197 return -EINVAL;
198 }
199
200 if (rdtgroup_cbm_overlaps(s, d, cbm: cbm_val, closid, exclusive: false)) {
201 if (mode == RDT_MODE_EXCLUSIVE ||
202 mode == RDT_MODE_PSEUDO_LOCKSETUP) {
203 rdt_last_cmd_puts(s: "Overlaps with other group\n");
204 return -EINVAL;
205 }
206 }
207
208 cfg->new_ctrl = cbm_val;
209 cfg->have_new_ctrl = true;
210
211 return 0;
212}
213
214/*
215 * For each domain in this resource we expect to find a series of:
216 * id=mask
217 * separated by ";". The "id" is in decimal, and must match one of
218 * the "id"s for this resource.
219 */
220static int parse_line(char *line, struct resctrl_schema *s,
221 struct rdtgroup *rdtgrp)
222{
223 enum resctrl_conf_type t = s->conf_type;
224 ctrlval_parser_t *parse_ctrlval = NULL;
225 struct resctrl_staged_config *cfg;
226 struct rdt_resource *r = s->res;
227 struct rdt_parse_data data;
228 struct rdt_ctrl_domain *d;
229 char *dom = NULL, *id;
230 unsigned long dom_id;
231
232 /* Walking r->domains, ensure it can't race with cpuhp */
233 lockdep_assert_cpus_held();
234
235 switch (r->schema_fmt) {
236 case RESCTRL_SCHEMA_BITMAP:
237 parse_ctrlval = &parse_cbm;
238 break;
239 case RESCTRL_SCHEMA_RANGE:
240 parse_ctrlval = &parse_bw;
241 break;
242 }
243
244 if (WARN_ON_ONCE(!parse_ctrlval))
245 return -EINVAL;
246
247 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP &&
248 (r->rid == RDT_RESOURCE_MBA || r->rid == RDT_RESOURCE_SMBA)) {
249 rdt_last_cmd_puts(s: "Cannot pseudo-lock MBA resource\n");
250 return -EINVAL;
251 }
252
253next:
254 if (!line || line[0] == '\0')
255 return 0;
256 dom = strsep(&line, ";");
257 id = strsep(&dom, "=");
258 if (!dom || kstrtoul(s: id, base: 10, res: &dom_id)) {
259 rdt_last_cmd_puts(s: "Missing '=' or non-numeric domain\n");
260 return -EINVAL;
261 }
262 dom = strim(dom);
263 list_for_each_entry(d, &r->ctrl_domains, hdr.list) {
264 if (d->hdr.id == dom_id) {
265 data.buf = dom;
266 data.closid = rdtgrp->closid;
267 data.mode = rdtgrp->mode;
268 if (parse_ctrlval(&data, s, d))
269 return -EINVAL;
270 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
271 cfg = &d->staged_config[t];
272 /*
273 * In pseudo-locking setup mode and just
274 * parsed a valid CBM that should be
275 * pseudo-locked. Only one locked region per
276 * resource group and domain so just do
277 * the required initialization for single
278 * region and return.
279 */
280 rdtgrp->plr->s = s;
281 rdtgrp->plr->d = d;
282 rdtgrp->plr->cbm = cfg->new_ctrl;
283 d->plr = rdtgrp->plr;
284 return 0;
285 }
286 goto next;
287 }
288 }
289 return -EINVAL;
290}
291
292static int rdtgroup_parse_resource(char *resname, char *tok,
293 struct rdtgroup *rdtgrp)
294{
295 struct resctrl_schema *s;
296
297 list_for_each_entry(s, &resctrl_schema_all, list) {
298 if (!strcmp(resname, s->name) && rdtgrp->closid < s->num_closid)
299 return parse_line(line: tok, s, rdtgrp);
300 }
301 rdt_last_cmd_printf(fmt: "Unknown or unsupported resource name '%s'\n", resname);
302 return -EINVAL;
303}
304
305ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of,
306 char *buf, size_t nbytes, loff_t off)
307{
308 struct resctrl_schema *s;
309 struct rdtgroup *rdtgrp;
310 struct rdt_resource *r;
311 char *tok, *resname;
312 int ret = 0;
313
314 /* Valid input requires a trailing newline */
315 if (nbytes == 0 || buf[nbytes - 1] != '\n')
316 return -EINVAL;
317 buf[nbytes - 1] = '\0';
318
319 rdtgrp = rdtgroup_kn_lock_live(kn: of->kn);
320 if (!rdtgrp) {
321 rdtgroup_kn_unlock(kn: of->kn);
322 return -ENOENT;
323 }
324 rdt_last_cmd_clear();
325
326 /*
327 * No changes to pseudo-locked region allowed. It has to be removed
328 * and re-created instead.
329 */
330 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
331 ret = -EINVAL;
332 rdt_last_cmd_puts(s: "Resource group is pseudo-locked\n");
333 goto out;
334 }
335
336 rdt_staged_configs_clear();
337
338 while ((tok = strsep(&buf, "\n")) != NULL) {
339 resname = strim(strsep(&tok, ":"));
340 if (!tok) {
341 rdt_last_cmd_puts(s: "Missing ':'\n");
342 ret = -EINVAL;
343 goto out;
344 }
345 if (tok[0] == '\0') {
346 rdt_last_cmd_printf(fmt: "Missing '%s' value\n", resname);
347 ret = -EINVAL;
348 goto out;
349 }
350 ret = rdtgroup_parse_resource(resname, tok, rdtgrp);
351 if (ret)
352 goto out;
353 }
354
355 list_for_each_entry(s, &resctrl_schema_all, list) {
356 r = s->res;
357
358 /*
359 * Writes to mba_sc resources update the software controller,
360 * not the control MSR.
361 */
362 if (is_mba_sc(r))
363 continue;
364
365 ret = resctrl_arch_update_domains(r, closid: rdtgrp->closid);
366 if (ret)
367 goto out;
368 }
369
370 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
371 /*
372 * If pseudo-locking fails we keep the resource group in
373 * mode RDT_MODE_PSEUDO_LOCKSETUP with its class of service
374 * active and updated for just the domain the pseudo-locked
375 * region was requested for.
376 */
377 ret = rdtgroup_pseudo_lock_create(rdtgrp);
378 }
379
380out:
381 rdt_staged_configs_clear();
382 rdtgroup_kn_unlock(kn: of->kn);
383 return ret ?: nbytes;
384}
385
386static void show_doms(struct seq_file *s, struct resctrl_schema *schema,
387 char *resource_name, int closid)
388{
389 struct rdt_resource *r = schema->res;
390 struct rdt_ctrl_domain *dom;
391 bool sep = false;
392 u32 ctrl_val;
393
394 /* Walking r->domains, ensure it can't race with cpuhp */
395 lockdep_assert_cpus_held();
396
397 if (resource_name)
398 seq_printf(m: s, fmt: "%*s:", max_name_width, resource_name);
399 list_for_each_entry(dom, &r->ctrl_domains, hdr.list) {
400 if (sep)
401 seq_puts(m: s, s: ";");
402
403 if (is_mba_sc(r))
404 ctrl_val = dom->mbps_val[closid];
405 else
406 ctrl_val = resctrl_arch_get_config(r, d: dom, closid,
407 type: schema->conf_type);
408
409 seq_printf(m: s, fmt: schema->fmt_str, dom->hdr.id, ctrl_val);
410 sep = true;
411 }
412 seq_puts(m: s, s: "\n");
413}
414
415int rdtgroup_schemata_show(struct kernfs_open_file *of,
416 struct seq_file *s, void *v)
417{
418 struct resctrl_schema *schema;
419 struct rdtgroup *rdtgrp;
420 int ret = 0;
421 u32 closid;
422
423 rdtgrp = rdtgroup_kn_lock_live(kn: of->kn);
424 if (rdtgrp) {
425 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
426 list_for_each_entry(schema, &resctrl_schema_all, list) {
427 seq_printf(m: s, fmt: "%s:uninitialized\n", schema->name);
428 }
429 } else if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
430 if (!rdtgrp->plr->d) {
431 rdt_last_cmd_clear();
432 rdt_last_cmd_puts(s: "Cache domain offline\n");
433 ret = -ENODEV;
434 } else {
435 seq_printf(m: s, fmt: "%s:%d=%x\n",
436 rdtgrp->plr->s->res->name,
437 rdtgrp->plr->d->hdr.id,
438 rdtgrp->plr->cbm);
439 }
440 } else {
441 closid = rdtgrp->closid;
442 list_for_each_entry(schema, &resctrl_schema_all, list) {
443 if (closid < schema->num_closid)
444 show_doms(s, schema, resource_name: schema->name, closid);
445 }
446 }
447 } else {
448 ret = -ENOENT;
449 }
450 rdtgroup_kn_unlock(kn: of->kn);
451 return ret;
452}
453
454static int smp_mon_event_count(void *arg)
455{
456 mon_event_count(info: arg);
457
458 return 0;
459}
460
461ssize_t rdtgroup_mba_mbps_event_write(struct kernfs_open_file *of,
462 char *buf, size_t nbytes, loff_t off)
463{
464 struct rdtgroup *rdtgrp;
465 int ret = 0;
466
467 /* Valid input requires a trailing newline */
468 if (nbytes == 0 || buf[nbytes - 1] != '\n')
469 return -EINVAL;
470 buf[nbytes - 1] = '\0';
471
472 rdtgrp = rdtgroup_kn_lock_live(kn: of->kn);
473 if (!rdtgrp) {
474 rdtgroup_kn_unlock(kn: of->kn);
475 return -ENOENT;
476 }
477 rdt_last_cmd_clear();
478
479 if (!strcmp(buf, "mbm_local_bytes")) {
480 if (resctrl_is_mon_event_enabled(eventid: QOS_L3_MBM_LOCAL_EVENT_ID))
481 rdtgrp->mba_mbps_event = QOS_L3_MBM_LOCAL_EVENT_ID;
482 else
483 ret = -EINVAL;
484 } else if (!strcmp(buf, "mbm_total_bytes")) {
485 if (resctrl_is_mon_event_enabled(eventid: QOS_L3_MBM_TOTAL_EVENT_ID))
486 rdtgrp->mba_mbps_event = QOS_L3_MBM_TOTAL_EVENT_ID;
487 else
488 ret = -EINVAL;
489 } else {
490 ret = -EINVAL;
491 }
492
493 if (ret)
494 rdt_last_cmd_printf(fmt: "Unsupported event id '%s'\n", buf);
495
496 rdtgroup_kn_unlock(kn: of->kn);
497
498 return ret ?: nbytes;
499}
500
501int rdtgroup_mba_mbps_event_show(struct kernfs_open_file *of,
502 struct seq_file *s, void *v)
503{
504 struct rdtgroup *rdtgrp;
505 int ret = 0;
506
507 rdtgrp = rdtgroup_kn_lock_live(kn: of->kn);
508
509 if (rdtgrp) {
510 switch (rdtgrp->mba_mbps_event) {
511 case QOS_L3_MBM_LOCAL_EVENT_ID:
512 seq_puts(m: s, s: "mbm_local_bytes\n");
513 break;
514 case QOS_L3_MBM_TOTAL_EVENT_ID:
515 seq_puts(m: s, s: "mbm_total_bytes\n");
516 break;
517 default:
518 pr_warn_once("Bad event %d\n", rdtgrp->mba_mbps_event);
519 ret = -EINVAL;
520 break;
521 }
522 } else {
523 ret = -ENOENT;
524 }
525
526 rdtgroup_kn_unlock(kn: of->kn);
527
528 return ret;
529}
530
531struct rdt_domain_hdr *resctrl_find_domain(struct list_head *h, int id,
532 struct list_head **pos)
533{
534 struct rdt_domain_hdr *d;
535 struct list_head *l;
536
537 list_for_each(l, h) {
538 d = list_entry(l, struct rdt_domain_hdr, list);
539 /* When id is found, return its domain. */
540 if (id == d->id)
541 return d;
542 /* Stop searching when finding id's position in sorted list. */
543 if (id < d->id)
544 break;
545 }
546
547 if (pos)
548 *pos = l;
549
550 return NULL;
551}
552
553void mon_event_read(struct rmid_read *rr, struct rdt_resource *r,
554 struct rdt_mon_domain *d, struct rdtgroup *rdtgrp,
555 cpumask_t *cpumask, int evtid, int first)
556{
557 int cpu;
558
559 /* When picking a CPU from cpu_mask, ensure it can't race with cpuhp */
560 lockdep_assert_cpus_held();
561
562 /*
563 * Setup the parameters to pass to mon_event_count() to read the data.
564 */
565 rr->rgrp = rdtgrp;
566 rr->evtid = evtid;
567 rr->r = r;
568 rr->d = d;
569 rr->first = first;
570 if (resctrl_arch_mbm_cntr_assign_enabled(r) &&
571 resctrl_is_mbm_event(eventid: evtid)) {
572 rr->is_mbm_cntr = true;
573 } else {
574 rr->arch_mon_ctx = resctrl_arch_mon_ctx_alloc(r, evtid);
575 if (IS_ERR(ptr: rr->arch_mon_ctx)) {
576 rr->err = -EINVAL;
577 return;
578 }
579 }
580
581 cpu = cpumask_any_housekeeping(mask: cpumask, RESCTRL_PICK_ANY_CPU);
582
583 /*
584 * cpumask_any_housekeeping() prefers housekeeping CPUs, but
585 * are all the CPUs nohz_full? If yes, pick a CPU to IPI.
586 * MPAM's resctrl_arch_rmid_read() is unable to read the
587 * counters on some platforms if its called in IRQ context.
588 */
589 if (tick_nohz_full_cpu(cpu))
590 smp_call_function_any(mask: cpumask, func: mon_event_count, info: rr, wait: 1);
591 else
592 smp_call_on_cpu(cpu, func: smp_mon_event_count, par: rr, phys: false);
593
594 if (rr->arch_mon_ctx)
595 resctrl_arch_mon_ctx_free(r, evtid, ctx: rr->arch_mon_ctx);
596}
597
598int rdtgroup_mondata_show(struct seq_file *m, void *arg)
599{
600 struct kernfs_open_file *of = m->private;
601 enum resctrl_res_level resid;
602 enum resctrl_event_id evtid;
603 struct rdt_domain_hdr *hdr;
604 struct rmid_read rr = {0};
605 struct rdt_mon_domain *d;
606 struct rdtgroup *rdtgrp;
607 int domid, cpu, ret = 0;
608 struct rdt_resource *r;
609 struct cacheinfo *ci;
610 struct mon_data *md;
611
612 rdtgrp = rdtgroup_kn_lock_live(kn: of->kn);
613 if (!rdtgrp) {
614 ret = -ENOENT;
615 goto out;
616 }
617
618 md = of->kn->priv;
619 if (WARN_ON_ONCE(!md)) {
620 ret = -EIO;
621 goto out;
622 }
623
624 resid = md->rid;
625 domid = md->domid;
626 evtid = md->evtid;
627 r = resctrl_arch_get_resource(l: resid);
628
629 if (md->sum) {
630 /*
631 * This file requires summing across all domains that share
632 * the L3 cache id that was provided in the "domid" field of the
633 * struct mon_data. Search all domains in the resource for
634 * one that matches this cache id.
635 */
636 list_for_each_entry(d, &r->mon_domains, hdr.list) {
637 if (d->ci_id == domid) {
638 cpu = cpumask_any(&d->hdr.cpu_mask);
639 ci = get_cpu_cacheinfo_level(cpu, level: RESCTRL_L3_CACHE);
640 if (!ci)
641 continue;
642 rr.ci = ci;
643 mon_event_read(rr: &rr, r, NULL, rdtgrp,
644 cpumask: &ci->shared_cpu_map, evtid, first: false);
645 goto checkresult;
646 }
647 }
648 ret = -ENOENT;
649 goto out;
650 } else {
651 /*
652 * This file provides data from a single domain. Search
653 * the resource to find the domain with "domid".
654 */
655 hdr = resctrl_find_domain(h: &r->mon_domains, id: domid, NULL);
656 if (!hdr || WARN_ON_ONCE(hdr->type != RESCTRL_MON_DOMAIN)) {
657 ret = -ENOENT;
658 goto out;
659 }
660 d = container_of(hdr, struct rdt_mon_domain, hdr);
661 mon_event_read(rr: &rr, r, d, rdtgrp, cpumask: &d->hdr.cpu_mask, evtid, first: false);
662 }
663
664checkresult:
665
666 /*
667 * -ENOENT is a special case, set only when "mbm_event" counter assignment
668 * mode is enabled and no counter has been assigned.
669 */
670 if (rr.err == -EIO)
671 seq_puts(m, s: "Error\n");
672 else if (rr.err == -EINVAL)
673 seq_puts(m, s: "Unavailable\n");
674 else if (rr.err == -ENOENT)
675 seq_puts(m, s: "Unassigned\n");
676 else
677 seq_printf(m, fmt: "%llu\n", rr.val);
678
679out:
680 rdtgroup_kn_unlock(kn: of->kn);
681 return ret;
682}
683
684int resctrl_io_alloc_show(struct kernfs_open_file *of, struct seq_file *seq, void *v)
685{
686 struct resctrl_schema *s = rdt_kn_parent_priv(kn: of->kn);
687 struct rdt_resource *r = s->res;
688
689 mutex_lock(&rdtgroup_mutex);
690
691 if (r->cache.io_alloc_capable) {
692 if (resctrl_arch_get_io_alloc_enabled(r))
693 seq_puts(m: seq, s: "enabled\n");
694 else
695 seq_puts(m: seq, s: "disabled\n");
696 } else {
697 seq_puts(m: seq, s: "not supported\n");
698 }
699
700 mutex_unlock(lock: &rdtgroup_mutex);
701
702 return 0;
703}
704
705/*
706 * resctrl_io_alloc_closid_supported() - io_alloc feature utilizes the
707 * highest CLOSID value to direct I/O traffic. Ensure that io_alloc_closid
708 * is in the supported range.
709 */
710static bool resctrl_io_alloc_closid_supported(u32 io_alloc_closid)
711{
712 return io_alloc_closid < closids_supported();
713}
714
715/*
716 * Initialize io_alloc CLOSID cache resource CBM with all usable (shared
717 * and unused) cache portions.
718 */
719static int resctrl_io_alloc_init_cbm(struct resctrl_schema *s, u32 closid)
720{
721 enum resctrl_conf_type peer_type;
722 struct rdt_resource *r = s->res;
723 struct rdt_ctrl_domain *d;
724 int ret;
725
726 rdt_staged_configs_clear();
727
728 ret = rdtgroup_init_cat(s, closid);
729 if (ret < 0)
730 goto out;
731
732 /* Keep CDP_CODE and CDP_DATA of io_alloc CLOSID's CBM in sync. */
733 if (resctrl_arch_get_cdp_enabled(l: r->rid)) {
734 peer_type = resctrl_peer_type(my_type: s->conf_type);
735 list_for_each_entry(d, &s->res->ctrl_domains, hdr.list)
736 memcpy(&d->staged_config[peer_type],
737 &d->staged_config[s->conf_type],
738 sizeof(d->staged_config[0]));
739 }
740
741 ret = resctrl_arch_update_domains(r, closid);
742out:
743 rdt_staged_configs_clear();
744 return ret;
745}
746
747/*
748 * resctrl_io_alloc_closid() - io_alloc feature routes I/O traffic using
749 * the highest available CLOSID. Retrieve the maximum CLOSID supported by the
750 * resource. Note that if Code Data Prioritization (CDP) is enabled, the number
751 * of available CLOSIDs is reduced by half.
752 */
753u32 resctrl_io_alloc_closid(struct rdt_resource *r)
754{
755 if (resctrl_arch_get_cdp_enabled(l: r->rid))
756 return resctrl_arch_get_num_closid(r) / 2 - 1;
757 else
758 return resctrl_arch_get_num_closid(r) - 1;
759}
760
761ssize_t resctrl_io_alloc_write(struct kernfs_open_file *of, char *buf,
762 size_t nbytes, loff_t off)
763{
764 struct resctrl_schema *s = rdt_kn_parent_priv(kn: of->kn);
765 struct rdt_resource *r = s->res;
766 char const *grp_name;
767 u32 io_alloc_closid;
768 bool enable;
769 int ret;
770
771 ret = kstrtobool(s: buf, res: &enable);
772 if (ret)
773 return ret;
774
775 cpus_read_lock();
776 mutex_lock(&rdtgroup_mutex);
777
778 rdt_last_cmd_clear();
779
780 if (!r->cache.io_alloc_capable) {
781 rdt_last_cmd_printf(fmt: "io_alloc is not supported on %s\n", s->name);
782 ret = -ENODEV;
783 goto out_unlock;
784 }
785
786 /* If the feature is already up to date, no action is needed. */
787 if (resctrl_arch_get_io_alloc_enabled(r) == enable)
788 goto out_unlock;
789
790 io_alloc_closid = resctrl_io_alloc_closid(r);
791 if (!resctrl_io_alloc_closid_supported(io_alloc_closid)) {
792 rdt_last_cmd_printf(fmt: "io_alloc CLOSID (ctrl_hw_id) %u is not available\n",
793 io_alloc_closid);
794 ret = -EINVAL;
795 goto out_unlock;
796 }
797
798 if (enable) {
799 if (!closid_alloc_fixed(closid: io_alloc_closid)) {
800 grp_name = rdtgroup_name_by_closid(closid: io_alloc_closid);
801 WARN_ON_ONCE(!grp_name);
802 rdt_last_cmd_printf(fmt: "CLOSID (ctrl_hw_id) %u for io_alloc is used by %s group\n",
803 io_alloc_closid, grp_name ? grp_name : "another");
804 ret = -ENOSPC;
805 goto out_unlock;
806 }
807
808 ret = resctrl_io_alloc_init_cbm(s, closid: io_alloc_closid);
809 if (ret) {
810 rdt_last_cmd_puts(s: "Failed to initialize io_alloc allocations\n");
811 closid_free(closid: io_alloc_closid);
812 goto out_unlock;
813 }
814 } else {
815 closid_free(closid: io_alloc_closid);
816 }
817
818 ret = resctrl_arch_io_alloc_enable(r, enable);
819 if (enable && ret) {
820 rdt_last_cmd_puts(s: "Failed to enable io_alloc feature\n");
821 closid_free(closid: io_alloc_closid);
822 }
823
824out_unlock:
825 mutex_unlock(lock: &rdtgroup_mutex);
826 cpus_read_unlock();
827
828 return ret ?: nbytes;
829}
830
831int resctrl_io_alloc_cbm_show(struct kernfs_open_file *of, struct seq_file *seq, void *v)
832{
833 struct resctrl_schema *s = rdt_kn_parent_priv(kn: of->kn);
834 struct rdt_resource *r = s->res;
835 int ret = 0;
836
837 cpus_read_lock();
838 mutex_lock(&rdtgroup_mutex);
839
840 rdt_last_cmd_clear();
841
842 if (!r->cache.io_alloc_capable) {
843 rdt_last_cmd_printf(fmt: "io_alloc is not supported on %s\n", s->name);
844 ret = -ENODEV;
845 goto out_unlock;
846 }
847
848 if (!resctrl_arch_get_io_alloc_enabled(r)) {
849 rdt_last_cmd_printf(fmt: "io_alloc is not enabled on %s\n", s->name);
850 ret = -EINVAL;
851 goto out_unlock;
852 }
853
854 /*
855 * When CDP is enabled, the CBMs of the highest CLOSID of CDP_CODE and
856 * CDP_DATA are kept in sync. As a result, the io_alloc CBMs shown for
857 * either CDP resource are identical and accurately represent the CBMs
858 * used for I/O.
859 */
860 show_doms(s: seq, schema: s, NULL, closid: resctrl_io_alloc_closid(r));
861
862out_unlock:
863 mutex_unlock(lock: &rdtgroup_mutex);
864 cpus_read_unlock();
865 return ret;
866}
867
868static int resctrl_io_alloc_parse_line(char *line, struct rdt_resource *r,
869 struct resctrl_schema *s, u32 closid)
870{
871 enum resctrl_conf_type peer_type;
872 struct rdt_parse_data data;
873 struct rdt_ctrl_domain *d;
874 char *dom = NULL, *id;
875 unsigned long dom_id;
876
877next:
878 if (!line || line[0] == '\0')
879 return 0;
880
881 dom = strsep(&line, ";");
882 id = strsep(&dom, "=");
883 if (!dom || kstrtoul(s: id, base: 10, res: &dom_id)) {
884 rdt_last_cmd_puts(s: "Missing '=' or non-numeric domain\n");
885 return -EINVAL;
886 }
887
888 dom = strim(dom);
889 list_for_each_entry(d, &r->ctrl_domains, hdr.list) {
890 if (d->hdr.id == dom_id) {
891 data.buf = dom;
892 data.mode = RDT_MODE_SHAREABLE;
893 data.closid = closid;
894 if (parse_cbm(data: &data, s, d))
895 return -EINVAL;
896 /*
897 * Keep io_alloc CLOSID's CBM of CDP_CODE and CDP_DATA
898 * in sync.
899 */
900 if (resctrl_arch_get_cdp_enabled(l: r->rid)) {
901 peer_type = resctrl_peer_type(my_type: s->conf_type);
902 memcpy(&d->staged_config[peer_type],
903 &d->staged_config[s->conf_type],
904 sizeof(d->staged_config[0]));
905 }
906 goto next;
907 }
908 }
909
910 return -EINVAL;
911}
912
913ssize_t resctrl_io_alloc_cbm_write(struct kernfs_open_file *of, char *buf,
914 size_t nbytes, loff_t off)
915{
916 struct resctrl_schema *s = rdt_kn_parent_priv(kn: of->kn);
917 struct rdt_resource *r = s->res;
918 u32 io_alloc_closid;
919 int ret = 0;
920
921 /* Valid input requires a trailing newline */
922 if (nbytes == 0 || buf[nbytes - 1] != '\n')
923 return -EINVAL;
924
925 buf[nbytes - 1] = '\0';
926
927 cpus_read_lock();
928 mutex_lock(&rdtgroup_mutex);
929 rdt_last_cmd_clear();
930
931 if (!r->cache.io_alloc_capable) {
932 rdt_last_cmd_printf(fmt: "io_alloc is not supported on %s\n", s->name);
933 ret = -ENODEV;
934 goto out_unlock;
935 }
936
937 if (!resctrl_arch_get_io_alloc_enabled(r)) {
938 rdt_last_cmd_printf(fmt: "io_alloc is not enabled on %s\n", s->name);
939 ret = -EINVAL;
940 goto out_unlock;
941 }
942
943 io_alloc_closid = resctrl_io_alloc_closid(r);
944
945 rdt_staged_configs_clear();
946 ret = resctrl_io_alloc_parse_line(line: buf, r, s, closid: io_alloc_closid);
947 if (ret)
948 goto out_clear_configs;
949
950 ret = resctrl_arch_update_domains(r, closid: io_alloc_closid);
951
952out_clear_configs:
953 rdt_staged_configs_clear();
954out_unlock:
955 mutex_unlock(lock: &rdtgroup_mutex);
956 cpus_read_unlock();
957
958 return ret ?: nbytes;
959}
960

source code of linux/fs/resctrl/ctrlmondata.c