arch/x86/kernel/cpu/resctrl/ctrlmondata.c

   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 <[email protected]>
  10  *    Tony Luck <[email protected]>
  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 "internal.h"
  23
  24 /*
  25  * Check whether MBA bandwidth percentage value is correct. The value is
  26  * checked against the minimum and max bandwidth values specified by the
  27  * hardware. The allocated bandwidth percentage is rounded to the next
  28  * control step available on the hardware.
  29  */
  30 static bool bw_validate(char *buf, unsigned long *data, struct rdt_resource *r)
  31 {
  32         unsigned long bw;
  33         int ret;
  34
  35         /*
  36          * Only linear delay values is supported for current Intel SKUs.
  37          */
  38         if (!r->membw.delay_linear && r->membw.arch_needs_linear) {
  39                 rdt_last_cmd_puts("No support for non-linear MB domains\n");
  40                 return false;
  41         }
  42
  43         ret = kstrtoul(buf, 10, &bw);
  44         if (ret) {
  45                 rdt_last_cmd_printf("Non-decimal digit in MB value %s\n", buf);
  46                 return false;
  47         }
  48
  49         if ((bw < r->membw.min_bw || bw > r->default_ctrl) &&
  50             !is_mba_sc(r)) {
  51                 rdt_last_cmd_printf("MB value %ld out of range [%d,%d]\n", bw,
  52                                     r->membw.min_bw, r->default_ctrl);
  53                 return false;
  54         }
  55
  56         *data = roundup(bw, (unsigned long)r->membw.bw_gran);
  57         return true;
  58 }
  59
  60 int parse_bw(struct rdt_parse_data *data, struct resctrl_schema *s,
  61              struct rdt_domain *d)
  62 {
  63         struct resctrl_staged_config *cfg;
  64         u32 closid = data->rdtgrp->closid;
  65         struct rdt_resource *r = s->res;
  66         unsigned long bw_val;
  67
  68         cfg = &d->staged_config[s->conf_type];
  69         if (cfg->have_new_ctrl) {
  70                 rdt_last_cmd_printf("Duplicate domain %d\n", d->id);
  71                 return -EINVAL;
  72         }
  73
  74         if (!bw_validate(data->buf, &bw_val, r))
  75                 return -EINVAL;
  76
  77         if (is_mba_sc(r)) {
  78                 d->mbps_val[closid] = bw_val;
  79                 return 0;
  80         }
  81
  82         cfg->new_ctrl = bw_val;
  83         cfg->have_new_ctrl = true;
  84
  85         return 0;
  86 }
  87
  88 /*
  89  * Check whether a cache bit mask is valid.
  90  * For Intel the SDM says:
  91  *      Please note that all (and only) contiguous '1' combinations
  92  *      are allowed (e.g. FFFFH, 0FF0H, 003CH, etc.).
  93  * Additionally Haswell requires at least two bits set.
  94  * AMD allows non-contiguous bitmasks.
  95  */
  96 static bool cbm_validate(char *buf, u32 *data, struct rdt_resource *r)
  97 {
  98         unsigned long first_bit, zero_bit, val;
  99         unsigned int cbm_len = r->cache.cbm_len;
 100         int ret;
 101
 102         ret = kstrtoul(buf, 16, &val);
 103         if (ret) {
 104                 rdt_last_cmd_printf("Non-hex character in the mask %s\n", buf);
 105                 return false;
 106         }
 107
 108         if ((r->cache.min_cbm_bits > 0 && val == 0) || val > r->default_ctrl) {
 109                 rdt_last_cmd_puts("Mask out of range\n");
 110                 return false;
 111         }
 112
 113         first_bit = find_first_bit(&val, cbm_len);
 114         zero_bit = find_next_zero_bit(&val, cbm_len, first_bit);
 115
 116         /* Are non-contiguous bitmaps allowed? */
 117         if (!r->cache.arch_has_sparse_bitmaps &&
 118             (find_next_bit(&val, cbm_len, zero_bit) < cbm_len)) {
 119                 rdt_last_cmd_printf("The mask %lx has non-consecutive 1-bits\n", val);
 120                 return false;
 121         }
 122
 123         if ((zero_bit - first_bit) < r->cache.min_cbm_bits) {
 124                 rdt_last_cmd_printf("Need at least %d bits in the mask\n",
 125                                     r->cache.min_cbm_bits);
 126                 return false;
 127         }
 128
 129         *data = val;
 130         return true;
 131 }
 132
 133 /*
 134  * Read one cache bit mask (hex). Check that it is valid for the current
 135  * resource type.
 136  */
 137 int parse_cbm(struct rdt_parse_data *data, struct resctrl_schema *s,
 138               struct rdt_domain *d)
 139 {
 140         struct rdtgroup *rdtgrp = data->rdtgrp;
 141         struct resctrl_staged_config *cfg;
 142         struct rdt_resource *r = s->res;
 143         u32 cbm_val;
 144
 145         cfg = &d->staged_config[s->conf_type];
 146         if (cfg->have_new_ctrl) {
 147                 rdt_last_cmd_printf("Duplicate domain %d\n", d->id);
 148                 return -EINVAL;
 149         }
 150
 151         /*
 152          * Cannot set up more than one pseudo-locked region in a cache
 153          * hierarchy.
 154          */
 155         if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP &&
 156             rdtgroup_pseudo_locked_in_hierarchy(d)) {
 157                 rdt_last_cmd_puts("Pseudo-locked region in hierarchy\n");
 158                 return -EINVAL;
 159         }
 160
 161         if (!cbm_validate(data->buf, &cbm_val, r))
 162                 return -EINVAL;
 163
 164         if ((rdtgrp->mode == RDT_MODE_EXCLUSIVE ||
 165              rdtgrp->mode == RDT_MODE_SHAREABLE) &&
 166             rdtgroup_cbm_overlaps_pseudo_locked(d, cbm_val)) {
 167                 rdt_last_cmd_puts("CBM overlaps with pseudo-locked region\n");
 168                 return -EINVAL;
 169         }
 170
 171         /*
 172          * The CBM may not overlap with the CBM of another closid if
 173          * either is exclusive.
 174          */
 175         if (rdtgroup_cbm_overlaps(s, d, cbm_val, rdtgrp->closid, true)) {
 176                 rdt_last_cmd_puts("Overlaps with exclusive group\n");
 177                 return -EINVAL;
 178         }
 179
 180         if (rdtgroup_cbm_overlaps(s, d, cbm_val, rdtgrp->closid, false)) {
 181                 if (rdtgrp->mode == RDT_MODE_EXCLUSIVE ||
 182                     rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
 183                         rdt_last_cmd_puts("Overlaps with other group\n");
 184                         return -EINVAL;
 185                 }
 186         }
 187
 188         cfg->new_ctrl = cbm_val;
 189         cfg->have_new_ctrl = true;
 190
 191         return 0;
 192 }
 193
 194 /*
 195  * For each domain in this resource we expect to find a series of:
 196  *      id=mask
 197  * separated by ";". The "id" is in decimal, and must match one of
 198  * the "id"s for this resource.
 199  */
 200 static int parse_line(char *line, struct resctrl_schema *s,
 201                       struct rdtgroup *rdtgrp)
 202 {
 203         enum resctrl_conf_type t = s->conf_type;
 204         struct resctrl_staged_config *cfg;
 205         struct rdt_resource *r = s->res;
 206         struct rdt_parse_data data;
 207         char *dom = NULL, *id;
 208         struct rdt_domain *d;
 209         unsigned long dom_id;
 210
 211         if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP &&
 212             r->rid == RDT_RESOURCE_MBA) {
 213                 rdt_last_cmd_puts("Cannot pseudo-lock MBA resource\n");
 214                 return -EINVAL;
 215         }
 216
 217 next:
 218         if (!line || line[0] == '\0')
 219                 return 0;
 220         dom = strsep(&line, ";");
 221         id = strsep(&dom, "=");
 222         if (!dom || kstrtoul(id, 10, &dom_id)) {
 223                 rdt_last_cmd_puts("Missing '=' or non-numeric domain\n");
 224                 return -EINVAL;
 225         }
 226         dom = strim(dom);
 227         list_for_each_entry(d, &r->domains, list) {
 228                 if (d->id == dom_id) {
 229                         data.buf = dom;
 230                         data.rdtgrp = rdtgrp;
 231                         if (r->parse_ctrlval(&data, s, d))
 232                                 return -EINVAL;
 233                         if (rdtgrp->mode ==  RDT_MODE_PSEUDO_LOCKSETUP) {
 234                                 cfg = &d->staged_config[t];
 235                                 /*
 236                                  * In pseudo-locking setup mode and just
 237                                  * parsed a valid CBM that should be
 238                                  * pseudo-locked. Only one locked region per
 239                                  * resource group and domain so just do
 240                                  * the required initialization for single
 241                                  * region and return.
 242                                  */
 243                                 rdtgrp->plr->s = s;
 244                                 rdtgrp->plr->d = d;
 245                                 rdtgrp->plr->cbm = cfg->new_ctrl;
 246                                 d->plr = rdtgrp->plr;
 247                                 return 0;
 248                         }
 249                         goto next;
 250                 }
 251         }
 252         return -EINVAL;
 253 }
 254
 255 static u32 get_config_index(u32 closid, enum resctrl_conf_type type)
 256 {
 257         switch (type) {
 258         default:
 259         case CDP_NONE:
 260                 return closid;
 261         case CDP_CODE:
 262                 return closid * 2 + 1;
 263         case CDP_DATA:
 264                 return closid * 2;
 265         }
 266 }
 267
 268 static bool apply_config(struct rdt_hw_domain *hw_dom,
 269                          struct resctrl_staged_config *cfg, u32 idx,
 270                          cpumask_var_t cpu_mask)
 271 {
 272         struct rdt_domain *dom = &hw_dom->d_resctrl;
 273
 274         if (cfg->new_ctrl != hw_dom->ctrl_val[idx]) {
 275                 cpumask_set_cpu(cpumask_any(&dom->cpu_mask), cpu_mask);
 276                 hw_dom->ctrl_val[idx] = cfg->new_ctrl;
 277
 278                 return true;
 279         }
 280
 281         return false;
 282 }
 283
 284 int resctrl_arch_update_one(struct rdt_resource *r, struct rdt_domain *d,
 285                             u32 closid, enum resctrl_conf_type t, u32 cfg_val)
 286 {
 287         struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r);
 288         struct rdt_hw_domain *hw_dom = resctrl_to_arch_dom(d);
 289         u32 idx = get_config_index(closid, t);
 290         struct msr_param msr_param;
 291
 292         if (!cpumask_test_cpu(smp_processor_id(), &d->cpu_mask))
 293                 return -EINVAL;
 294
 295         hw_dom->ctrl_val[idx] = cfg_val;
 296
 297         msr_param.res = r;
 298         msr_param.low = idx;
 299         msr_param.high = idx + 1;
 300         hw_res->msr_update(d, &msr_param, r);
 301
 302         return 0;
 303 }
 304
 305 int resctrl_arch_update_domains(struct rdt_resource *r, u32 closid)
 306 {
 307         struct resctrl_staged_config *cfg;
 308         struct rdt_hw_domain *hw_dom;
 309         struct msr_param msr_param;
 310         enum resctrl_conf_type t;
 311         cpumask_var_t cpu_mask;
 312         struct rdt_domain *d;
 313         int cpu;
 314         u32 idx;
 315
 316         if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
 317                 return -ENOMEM;
 318
 319         msr_param.res = NULL;
 320         list_for_each_entry(d, &r->domains, list) {
 321                 hw_dom = resctrl_to_arch_dom(d);
 322                 for (t = 0; t < CDP_NUM_TYPES; t++) {
 323                         cfg = &hw_dom->d_resctrl.staged_config[t];
 324                         if (!cfg->have_new_ctrl)
 325                                 continue;
 326
 327                         idx = get_config_index(closid, t);
 328                         if (!apply_config(hw_dom, cfg, idx, cpu_mask))
 329                                 continue;
 330
 331                         if (!msr_param.res) {
 332                                 msr_param.low = idx;
 333                                 msr_param.high = msr_param.low + 1;
 334                                 msr_param.res = r;
 335                         } else {
 336                                 msr_param.low = min(msr_param.low, idx);
 337                                 msr_param.high = max(msr_param.high, idx + 1);
 338                         }
 339                 }
 340         }
 341
 342         if (cpumask_empty(cpu_mask))
 343                 goto done;
 344         cpu = get_cpu();
 345         /* Update resource control msr on this CPU if it's in cpu_mask. */
 346         if (cpumask_test_cpu(cpu, cpu_mask))
 347                 rdt_ctrl_update(&msr_param);
 348         /* Update resource control msr on other CPUs. */
 349         smp_call_function_many(cpu_mask, rdt_ctrl_update, &msr_param, 1);
 350         put_cpu();
 351
 352 done:
 353         free_cpumask_var(cpu_mask);
 354
 355         return 0;
 356 }
 357
 358 static int rdtgroup_parse_resource(char *resname, char *tok,
 359                                    struct rdtgroup *rdtgrp)
 360 {
 361         struct resctrl_schema *s;
 362
 363         list_for_each_entry(s, &resctrl_schema_all, list) {
 364                 if (!strcmp(resname, s->name) && rdtgrp->closid < s->num_closid)
 365                         return parse_line(tok, s, rdtgrp);
 366         }
 367         rdt_last_cmd_printf("Unknown or unsupported resource name '%s'\n", resname);
 368         return -EINVAL;
 369 }
 370
 371 ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of,
 372                                 char *buf, size_t nbytes, loff_t off)
 373 {
 374         struct resctrl_schema *s;
 375         struct rdtgroup *rdtgrp;
 376         struct rdt_domain *dom;
 377         struct rdt_resource *r;
 378         char *tok, *resname;
 379         int ret = 0;
 380
 381         /* Valid input requires a trailing newline */
 382         if (nbytes == 0 || buf[nbytes - 1] != '\n')
 383                 return -EINVAL;
 384         buf[nbytes - 1] = '\0';
 385
 386         cpus_read_lock();
 387         rdtgrp = rdtgroup_kn_lock_live(of->kn);
 388         if (!rdtgrp) {
 389                 rdtgroup_kn_unlock(of->kn);
 390                 cpus_read_unlock();
 391                 return -ENOENT;
 392         }
 393         rdt_last_cmd_clear();
 394
 395         /*
 396          * No changes to pseudo-locked region allowed. It has to be removed
 397          * and re-created instead.
 398          */
 399         if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
 400                 ret = -EINVAL;
 401                 rdt_last_cmd_puts("Resource group is pseudo-locked\n");
 402                 goto out;
 403         }
 404
 405         list_for_each_entry(s, &resctrl_schema_all, list) {
 406                 list_for_each_entry(dom, &s->res->domains, list)
 407                         memset(dom->staged_config, 0, sizeof(dom->staged_config));
 408         }
 409
 410         while ((tok = strsep(&buf, "\n")) != NULL) {
 411                 resname = strim(strsep(&tok, ":"));
 412                 if (!tok) {
 413                         rdt_last_cmd_puts("Missing ':'\n");
 414                         ret = -EINVAL;
 415                         goto out;
 416                 }
 417                 if (tok[0] == '\0') {
 418                         rdt_last_cmd_printf("Missing '%s' value\n", resname);
 419                         ret = -EINVAL;
 420                         goto out;
 421                 }
 422                 ret = rdtgroup_parse_resource(resname, tok, rdtgrp);
 423                 if (ret)
 424                         goto out;
 425         }
 426
 427         list_for_each_entry(s, &resctrl_schema_all, list) {
 428                 r = s->res;
 429
 430                 /*
 431                  * Writes to mba_sc resources update the software controller,
 432                  * not the control MSR.
 433                  */
 434                 if (is_mba_sc(r))
 435                         continue;
 436
 437                 ret = resctrl_arch_update_domains(r, rdtgrp->closid);
 438                 if (ret)
 439                         goto out;
 440         }
 441
 442         if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
 443                 /*
 444                  * If pseudo-locking fails we keep the resource group in
 445                  * mode RDT_MODE_PSEUDO_LOCKSETUP with its class of service
 446                  * active and updated for just the domain the pseudo-locked
 447                  * region was requested for.
 448                  */
 449                 ret = rdtgroup_pseudo_lock_create(rdtgrp);
 450         }
 451
 452 out:
 453         rdtgroup_kn_unlock(of->kn);
 454         cpus_read_unlock();
 455         return ret ?: nbytes;
 456 }
 457
 458 u32 resctrl_arch_get_config(struct rdt_resource *r, struct rdt_domain *d,
 459                             u32 closid, enum resctrl_conf_type type)
 460 {
 461         struct rdt_hw_domain *hw_dom = resctrl_to_arch_dom(d);
 462         u32 idx = get_config_index(closid, type);
 463
 464         return hw_dom->ctrl_val[idx];
 465 }
 466
 467 static void show_doms(struct seq_file *s, struct resctrl_schema *schema, int closid)
 468 {
 469         struct rdt_resource *r = schema->res;
 470         struct rdt_domain *dom;
 471         bool sep = false;
 472         u32 ctrl_val;
 473
 474         seq_printf(s, "%*s:", max_name_width, schema->name);
 475         list_for_each_entry(dom, &r->domains, list) {
 476                 if (sep)
 477                         seq_puts(s, ";");
 478
 479                 if (is_mba_sc(r))
 480                         ctrl_val = dom->mbps_val[closid];
 481                 else
 482                         ctrl_val = resctrl_arch_get_config(r, dom, closid,
 483                                                            schema->conf_type);
 484
 485                 seq_printf(s, r->format_str, dom->id, max_data_width,
 486                            ctrl_val);
 487                 sep = true;
 488         }
 489         seq_puts(s, "\n");
 490 }
 491
 492 int rdtgroup_schemata_show(struct kernfs_open_file *of,
 493                            struct seq_file *s, void *v)
 494 {
 495         struct resctrl_schema *schema;
 496         struct rdtgroup *rdtgrp;
 497         int ret = 0;
 498         u32 closid;
 499
 500         rdtgrp = rdtgroup_kn_lock_live(of->kn);
 501         if (rdtgrp) {
 502                 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
 503                         list_for_each_entry(schema, &resctrl_schema_all, list) {
 504                                 seq_printf(s, "%s:uninitialized\n", schema->name);
 505                         }
 506                 } else if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
 507                         if (!rdtgrp->plr->d) {
 508                                 rdt_last_cmd_clear();
 509                                 rdt_last_cmd_puts("Cache domain offline\n");
 510                                 ret = -ENODEV;
 511                         } else {
 512                                 seq_printf(s, "%s:%d=%x\n",
 513                                            rdtgrp->plr->s->res->name,
 514                                            rdtgrp->plr->d->id,
 515                                            rdtgrp->plr->cbm);
 516                         }
 517                 } else {
 518                         closid = rdtgrp->closid;
 519                         list_for_each_entry(schema, &resctrl_schema_all, list) {
 520                                 if (closid < schema->num_closid)
 521                                         show_doms(s, schema, closid);
 522                         }
 523                 }
 524         } else {
 525                 ret = -ENOENT;
 526         }
 527         rdtgroup_kn_unlock(of->kn);
 528         return ret;
 529 }
 530
 531 void mon_event_read(struct rmid_read *rr, struct rdt_resource *r,
 532                     struct rdt_domain *d, struct rdtgroup *rdtgrp,
 533                     int evtid, int first)
 534 {
 535         /*
 536          * setup the parameters to send to the IPI to read the data.
 537          */
 538         rr->rgrp = rdtgrp;
 539         rr->evtid = evtid;
 540         rr->r = r;
 541         rr->d = d;
 542         rr->val = 0;
 543         rr->first = first;
 544
 545         smp_call_function_any(&d->cpu_mask, mon_event_count, rr, 1);
 546 }
 547
 548 int rdtgroup_mondata_show(struct seq_file *m, void *arg)
 549 {
 550         struct kernfs_open_file *of = m->private;
 551         u32 resid, evtid, domid;
 552         struct rdtgroup *rdtgrp;
 553         struct rdt_resource *r;
 554         union mon_data_bits md;
 555         struct rdt_domain *d;
 556         struct rmid_read rr;
 557         int ret = 0;
 558
 559         rdtgrp = rdtgroup_kn_lock_live(of->kn);
 560         if (!rdtgrp) {
 561                 ret = -ENOENT;
 562                 goto out;
 563         }
 564
 565         md.priv = of->kn->priv;
 566         resid = md.u.rid;
 567         domid = md.u.domid;
 568         evtid = md.u.evtid;
 569
 570         r = &rdt_resources_all[resid].r_resctrl;
 571         d = rdt_find_domain(r, domid, NULL);
 572         if (IS_ERR_OR_NULL(d)) {
 573                 ret = -ENOENT;
 574                 goto out;
 575         }
 576
 577         mon_event_read(&rr, r, d, rdtgrp, evtid, false);
 578
 579         if (rr.err == -EIO)
 580                 seq_puts(m, "Error\n");
 581         else if (rr.err == -EINVAL)
 582                 seq_puts(m, "Unavailable\n");
 583         else
 584                 seq_printf(m, "%llu\n", rr.val);
 585
 586 out:
 587         rdtgroup_kn_unlock(of->kn);
 588         return ret;
 589 }