1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * User interface for Resource Allocation in Resource Director Technology(RDT) 4 * 5 * Copyright (C) 2016 Intel Corporation 6 * 7 * Author: Fenghua Yu <fenghua.yu@intel.com> 8 * 9 * More information about RDT be found in the Intel (R) x86 Architecture 10 * Software Developer Manual. 11 */ 12 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 15 #include <linux/cacheinfo.h> 16 #include <linux/cpu.h> 17 #include <linux/debugfs.h> 18 #include <linux/fs.h> 19 #include <linux/fs_parser.h> 20 #include <linux/sysfs.h> 21 #include <linux/kernfs.h> 22 #include <linux/seq_buf.h> 23 #include <linux/seq_file.h> 24 #include <linux/sched/signal.h> 25 #include <linux/sched/task.h> 26 #include <linux/slab.h> 27 #include <linux/task_work.h> 28 #include <linux/user_namespace.h> 29 30 #include <uapi/linux/magic.h> 31 32 #include <asm/resctrl.h> 33 #include "internal.h" 34 35 DEFINE_STATIC_KEY_FALSE(rdt_enable_key); 36 DEFINE_STATIC_KEY_FALSE(rdt_mon_enable_key); 37 DEFINE_STATIC_KEY_FALSE(rdt_alloc_enable_key); 38 static struct kernfs_root *rdt_root; 39 struct rdtgroup rdtgroup_default; 40 LIST_HEAD(rdt_all_groups); 41 42 /* list of entries for the schemata file */ 43 LIST_HEAD(resctrl_schema_all); 44 45 /* Kernel fs node for "info" directory under root */ 46 static struct kernfs_node *kn_info; 47 48 /* Kernel fs node for "mon_groups" directory under root */ 49 static struct kernfs_node *kn_mongrp; 50 51 /* Kernel fs node for "mon_data" directory under root */ 52 static struct kernfs_node *kn_mondata; 53 54 static struct seq_buf last_cmd_status; 55 static char last_cmd_status_buf[512]; 56 57 struct dentry *debugfs_resctrl; 58 59 void rdt_last_cmd_clear(void) 60 { 61 lockdep_assert_held(&rdtgroup_mutex); 62 seq_buf_clear(&last_cmd_status); 63 } 64 65 void rdt_last_cmd_puts(const char *s) 66 { 67 lockdep_assert_held(&rdtgroup_mutex); 68 seq_buf_puts(&last_cmd_status, s); 69 } 70 71 void rdt_last_cmd_printf(const char *fmt, ...) 72 { 73 va_list ap; 74 75 va_start(ap, fmt); 76 lockdep_assert_held(&rdtgroup_mutex); 77 seq_buf_vprintf(&last_cmd_status, fmt, ap); 78 va_end(ap); 79 } 80 81 /* 82 * Trivial allocator for CLOSIDs. Since h/w only supports a small number, 83 * we can keep a bitmap of free CLOSIDs in a single integer. 84 * 85 * Using a global CLOSID across all resources has some advantages and 86 * some drawbacks: 87 * + We can simply set "current->closid" to assign a task to a resource 88 * group. 89 * + Context switch code can avoid extra memory references deciding which 90 * CLOSID to load into the PQR_ASSOC MSR 91 * - We give up some options in configuring resource groups across multi-socket 92 * systems. 93 * - Our choices on how to configure each resource become progressively more 94 * limited as the number of resources grows. 95 */ 96 static int closid_free_map; 97 static int closid_free_map_len; 98 99 int closids_supported(void) 100 { 101 return closid_free_map_len; 102 } 103 104 static void closid_init(void) 105 { 106 struct resctrl_schema *s; 107 u32 rdt_min_closid = 32; 108 109 /* Compute rdt_min_closid across all resources */ 110 list_for_each_entry(s, &resctrl_schema_all, list) 111 rdt_min_closid = min(rdt_min_closid, s->num_closid); 112 113 closid_free_map = BIT_MASK(rdt_min_closid) - 1; 114 115 /* CLOSID 0 is always reserved for the default group */ 116 closid_free_map &= ~1; 117 closid_free_map_len = rdt_min_closid; 118 } 119 120 static int closid_alloc(void) 121 { 122 u32 closid = ffs(closid_free_map); 123 124 if (closid == 0) 125 return -ENOSPC; 126 closid--; 127 closid_free_map &= ~(1 << closid); 128 129 return closid; 130 } 131 132 void closid_free(int closid) 133 { 134 closid_free_map |= 1 << closid; 135 } 136 137 /** 138 * closid_allocated - test if provided closid is in use 139 * @closid: closid to be tested 140 * 141 * Return: true if @closid is currently associated with a resource group, 142 * false if @closid is free 143 */ 144 static bool closid_allocated(unsigned int closid) 145 { 146 return (closid_free_map & (1 << closid)) == 0; 147 } 148 149 /** 150 * rdtgroup_mode_by_closid - Return mode of resource group with closid 151 * @closid: closid if the resource group 152 * 153 * Each resource group is associated with a @closid. Here the mode 154 * of a resource group can be queried by searching for it using its closid. 155 * 156 * Return: mode as &enum rdtgrp_mode of resource group with closid @closid 157 */ 158 enum rdtgrp_mode rdtgroup_mode_by_closid(int closid) 159 { 160 struct rdtgroup *rdtgrp; 161 162 list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 163 if (rdtgrp->closid == closid) 164 return rdtgrp->mode; 165 } 166 167 return RDT_NUM_MODES; 168 } 169 170 static const char * const rdt_mode_str[] = { 171 [RDT_MODE_SHAREABLE] = "shareable", 172 [RDT_MODE_EXCLUSIVE] = "exclusive", 173 [RDT_MODE_PSEUDO_LOCKSETUP] = "pseudo-locksetup", 174 [RDT_MODE_PSEUDO_LOCKED] = "pseudo-locked", 175 }; 176 177 /** 178 * rdtgroup_mode_str - Return the string representation of mode 179 * @mode: the resource group mode as &enum rdtgroup_mode 180 * 181 * Return: string representation of valid mode, "unknown" otherwise 182 */ 183 static const char *rdtgroup_mode_str(enum rdtgrp_mode mode) 184 { 185 if (mode < RDT_MODE_SHAREABLE || mode >= RDT_NUM_MODES) 186 return "unknown"; 187 188 return rdt_mode_str[mode]; 189 } 190 191 /* set uid and gid of rdtgroup dirs and files to that of the creator */ 192 static int rdtgroup_kn_set_ugid(struct kernfs_node *kn) 193 { 194 struct iattr iattr = { .ia_valid = ATTR_UID | ATTR_GID, 195 .ia_uid = current_fsuid(), 196 .ia_gid = current_fsgid(), }; 197 198 if (uid_eq(iattr.ia_uid, GLOBAL_ROOT_UID) && 199 gid_eq(iattr.ia_gid, GLOBAL_ROOT_GID)) 200 return 0; 201 202 return kernfs_setattr(kn, &iattr); 203 } 204 205 static int rdtgroup_add_file(struct kernfs_node *parent_kn, struct rftype *rft) 206 { 207 struct kernfs_node *kn; 208 int ret; 209 210 kn = __kernfs_create_file(parent_kn, rft->name, rft->mode, 211 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 212 0, rft->kf_ops, rft, NULL, NULL); 213 if (IS_ERR(kn)) 214 return PTR_ERR(kn); 215 216 ret = rdtgroup_kn_set_ugid(kn); 217 if (ret) { 218 kernfs_remove(kn); 219 return ret; 220 } 221 222 return 0; 223 } 224 225 static int rdtgroup_seqfile_show(struct seq_file *m, void *arg) 226 { 227 struct kernfs_open_file *of = m->private; 228 struct rftype *rft = of->kn->priv; 229 230 if (rft->seq_show) 231 return rft->seq_show(of, m, arg); 232 return 0; 233 } 234 235 static ssize_t rdtgroup_file_write(struct kernfs_open_file *of, char *buf, 236 size_t nbytes, loff_t off) 237 { 238 struct rftype *rft = of->kn->priv; 239 240 if (rft->write) 241 return rft->write(of, buf, nbytes, off); 242 243 return -EINVAL; 244 } 245 246 static const struct kernfs_ops rdtgroup_kf_single_ops = { 247 .atomic_write_len = PAGE_SIZE, 248 .write = rdtgroup_file_write, 249 .seq_show = rdtgroup_seqfile_show, 250 }; 251 252 static const struct kernfs_ops kf_mondata_ops = { 253 .atomic_write_len = PAGE_SIZE, 254 .seq_show = rdtgroup_mondata_show, 255 }; 256 257 static bool is_cpu_list(struct kernfs_open_file *of) 258 { 259 struct rftype *rft = of->kn->priv; 260 261 return rft->flags & RFTYPE_FLAGS_CPUS_LIST; 262 } 263 264 static int rdtgroup_cpus_show(struct kernfs_open_file *of, 265 struct seq_file *s, void *v) 266 { 267 struct rdtgroup *rdtgrp; 268 struct cpumask *mask; 269 int ret = 0; 270 271 rdtgrp = rdtgroup_kn_lock_live(of->kn); 272 273 if (rdtgrp) { 274 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 275 if (!rdtgrp->plr->d) { 276 rdt_last_cmd_clear(); 277 rdt_last_cmd_puts("Cache domain offline\n"); 278 ret = -ENODEV; 279 } else { 280 mask = &rdtgrp->plr->d->cpu_mask; 281 seq_printf(s, is_cpu_list(of) ? 282 "%*pbl\n" : "%*pb\n", 283 cpumask_pr_args(mask)); 284 } 285 } else { 286 seq_printf(s, is_cpu_list(of) ? "%*pbl\n" : "%*pb\n", 287 cpumask_pr_args(&rdtgrp->cpu_mask)); 288 } 289 } else { 290 ret = -ENOENT; 291 } 292 rdtgroup_kn_unlock(of->kn); 293 294 return ret; 295 } 296 297 /* 298 * This is safe against resctrl_sched_in() called from __switch_to() 299 * because __switch_to() is executed with interrupts disabled. A local call 300 * from update_closid_rmid() is protected against __switch_to() because 301 * preemption is disabled. 302 */ 303 static void update_cpu_closid_rmid(void *info) 304 { 305 struct rdtgroup *r = info; 306 307 if (r) { 308 this_cpu_write(pqr_state.default_closid, r->closid); 309 this_cpu_write(pqr_state.default_rmid, r->mon.rmid); 310 } 311 312 /* 313 * We cannot unconditionally write the MSR because the current 314 * executing task might have its own closid selected. Just reuse 315 * the context switch code. 316 */ 317 resctrl_sched_in(); 318 } 319 320 /* 321 * Update the PGR_ASSOC MSR on all cpus in @cpu_mask, 322 * 323 * Per task closids/rmids must have been set up before calling this function. 324 */ 325 static void 326 update_closid_rmid(const struct cpumask *cpu_mask, struct rdtgroup *r) 327 { 328 int cpu = get_cpu(); 329 330 if (cpumask_test_cpu(cpu, cpu_mask)) 331 update_cpu_closid_rmid(r); 332 smp_call_function_many(cpu_mask, update_cpu_closid_rmid, r, 1); 333 put_cpu(); 334 } 335 336 static int cpus_mon_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 337 cpumask_var_t tmpmask) 338 { 339 struct rdtgroup *prgrp = rdtgrp->mon.parent, *crgrp; 340 struct list_head *head; 341 342 /* Check whether cpus belong to parent ctrl group */ 343 cpumask_andnot(tmpmask, newmask, &prgrp->cpu_mask); 344 if (!cpumask_empty(tmpmask)) { 345 rdt_last_cmd_puts("Can only add CPUs to mongroup that belong to parent\n"); 346 return -EINVAL; 347 } 348 349 /* Check whether cpus are dropped from this group */ 350 cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 351 if (!cpumask_empty(tmpmask)) { 352 /* Give any dropped cpus to parent rdtgroup */ 353 cpumask_or(&prgrp->cpu_mask, &prgrp->cpu_mask, tmpmask); 354 update_closid_rmid(tmpmask, prgrp); 355 } 356 357 /* 358 * If we added cpus, remove them from previous group that owned them 359 * and update per-cpu rmid 360 */ 361 cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 362 if (!cpumask_empty(tmpmask)) { 363 head = &prgrp->mon.crdtgrp_list; 364 list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 365 if (crgrp == rdtgrp) 366 continue; 367 cpumask_andnot(&crgrp->cpu_mask, &crgrp->cpu_mask, 368 tmpmask); 369 } 370 update_closid_rmid(tmpmask, rdtgrp); 371 } 372 373 /* Done pushing/pulling - update this group with new mask */ 374 cpumask_copy(&rdtgrp->cpu_mask, newmask); 375 376 return 0; 377 } 378 379 static void cpumask_rdtgrp_clear(struct rdtgroup *r, struct cpumask *m) 380 { 381 struct rdtgroup *crgrp; 382 383 cpumask_andnot(&r->cpu_mask, &r->cpu_mask, m); 384 /* update the child mon group masks as well*/ 385 list_for_each_entry(crgrp, &r->mon.crdtgrp_list, mon.crdtgrp_list) 386 cpumask_and(&crgrp->cpu_mask, &r->cpu_mask, &crgrp->cpu_mask); 387 } 388 389 static int cpus_ctrl_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 390 cpumask_var_t tmpmask, cpumask_var_t tmpmask1) 391 { 392 struct rdtgroup *r, *crgrp; 393 struct list_head *head; 394 395 /* Check whether cpus are dropped from this group */ 396 cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 397 if (!cpumask_empty(tmpmask)) { 398 /* Can't drop from default group */ 399 if (rdtgrp == &rdtgroup_default) { 400 rdt_last_cmd_puts("Can't drop CPUs from default group\n"); 401 return -EINVAL; 402 } 403 404 /* Give any dropped cpus to rdtgroup_default */ 405 cpumask_or(&rdtgroup_default.cpu_mask, 406 &rdtgroup_default.cpu_mask, tmpmask); 407 update_closid_rmid(tmpmask, &rdtgroup_default); 408 } 409 410 /* 411 * If we added cpus, remove them from previous group and 412 * the prev group's child groups that owned them 413 * and update per-cpu closid/rmid. 414 */ 415 cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 416 if (!cpumask_empty(tmpmask)) { 417 list_for_each_entry(r, &rdt_all_groups, rdtgroup_list) { 418 if (r == rdtgrp) 419 continue; 420 cpumask_and(tmpmask1, &r->cpu_mask, tmpmask); 421 if (!cpumask_empty(tmpmask1)) 422 cpumask_rdtgrp_clear(r, tmpmask1); 423 } 424 update_closid_rmid(tmpmask, rdtgrp); 425 } 426 427 /* Done pushing/pulling - update this group with new mask */ 428 cpumask_copy(&rdtgrp->cpu_mask, newmask); 429 430 /* 431 * Clear child mon group masks since there is a new parent mask 432 * now and update the rmid for the cpus the child lost. 433 */ 434 head = &rdtgrp->mon.crdtgrp_list; 435 list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 436 cpumask_and(tmpmask, &rdtgrp->cpu_mask, &crgrp->cpu_mask); 437 update_closid_rmid(tmpmask, rdtgrp); 438 cpumask_clear(&crgrp->cpu_mask); 439 } 440 441 return 0; 442 } 443 444 static ssize_t rdtgroup_cpus_write(struct kernfs_open_file *of, 445 char *buf, size_t nbytes, loff_t off) 446 { 447 cpumask_var_t tmpmask, newmask, tmpmask1; 448 struct rdtgroup *rdtgrp; 449 int ret; 450 451 if (!buf) 452 return -EINVAL; 453 454 if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 455 return -ENOMEM; 456 if (!zalloc_cpumask_var(&newmask, GFP_KERNEL)) { 457 free_cpumask_var(tmpmask); 458 return -ENOMEM; 459 } 460 if (!zalloc_cpumask_var(&tmpmask1, GFP_KERNEL)) { 461 free_cpumask_var(tmpmask); 462 free_cpumask_var(newmask); 463 return -ENOMEM; 464 } 465 466 rdtgrp = rdtgroup_kn_lock_live(of->kn); 467 if (!rdtgrp) { 468 ret = -ENOENT; 469 goto unlock; 470 } 471 472 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 473 rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 474 ret = -EINVAL; 475 rdt_last_cmd_puts("Pseudo-locking in progress\n"); 476 goto unlock; 477 } 478 479 if (is_cpu_list(of)) 480 ret = cpulist_parse(buf, newmask); 481 else 482 ret = cpumask_parse(buf, newmask); 483 484 if (ret) { 485 rdt_last_cmd_puts("Bad CPU list/mask\n"); 486 goto unlock; 487 } 488 489 /* check that user didn't specify any offline cpus */ 490 cpumask_andnot(tmpmask, newmask, cpu_online_mask); 491 if (!cpumask_empty(tmpmask)) { 492 ret = -EINVAL; 493 rdt_last_cmd_puts("Can only assign online CPUs\n"); 494 goto unlock; 495 } 496 497 if (rdtgrp->type == RDTCTRL_GROUP) 498 ret = cpus_ctrl_write(rdtgrp, newmask, tmpmask, tmpmask1); 499 else if (rdtgrp->type == RDTMON_GROUP) 500 ret = cpus_mon_write(rdtgrp, newmask, tmpmask); 501 else 502 ret = -EINVAL; 503 504 unlock: 505 rdtgroup_kn_unlock(of->kn); 506 free_cpumask_var(tmpmask); 507 free_cpumask_var(newmask); 508 free_cpumask_var(tmpmask1); 509 510 return ret ?: nbytes; 511 } 512 513 /** 514 * rdtgroup_remove - the helper to remove resource group safely 515 * @rdtgrp: resource group to remove 516 * 517 * On resource group creation via a mkdir, an extra kernfs_node reference is 518 * taken to ensure that the rdtgroup structure remains accessible for the 519 * rdtgroup_kn_unlock() calls where it is removed. 520 * 521 * Drop the extra reference here, then free the rdtgroup structure. 522 * 523 * Return: void 524 */ 525 static void rdtgroup_remove(struct rdtgroup *rdtgrp) 526 { 527 kernfs_put(rdtgrp->kn); 528 kfree(rdtgrp); 529 } 530 531 static void _update_task_closid_rmid(void *task) 532 { 533 /* 534 * If the task is still current on this CPU, update PQR_ASSOC MSR. 535 * Otherwise, the MSR is updated when the task is scheduled in. 536 */ 537 if (task == current) 538 resctrl_sched_in(); 539 } 540 541 static void update_task_closid_rmid(struct task_struct *t) 542 { 543 if (IS_ENABLED(CONFIG_SMP) && task_curr(t)) 544 smp_call_function_single(task_cpu(t), _update_task_closid_rmid, t, 1); 545 else 546 _update_task_closid_rmid(t); 547 } 548 549 static int __rdtgroup_move_task(struct task_struct *tsk, 550 struct rdtgroup *rdtgrp) 551 { 552 /* If the task is already in rdtgrp, no need to move the task. */ 553 if ((rdtgrp->type == RDTCTRL_GROUP && tsk->closid == rdtgrp->closid && 554 tsk->rmid == rdtgrp->mon.rmid) || 555 (rdtgrp->type == RDTMON_GROUP && tsk->rmid == rdtgrp->mon.rmid && 556 tsk->closid == rdtgrp->mon.parent->closid)) 557 return 0; 558 559 /* 560 * Set the task's closid/rmid before the PQR_ASSOC MSR can be 561 * updated by them. 562 * 563 * For ctrl_mon groups, move both closid and rmid. 564 * For monitor groups, can move the tasks only from 565 * their parent CTRL group. 566 */ 567 568 if (rdtgrp->type == RDTCTRL_GROUP) { 569 WRITE_ONCE(tsk->closid, rdtgrp->closid); 570 WRITE_ONCE(tsk->rmid, rdtgrp->mon.rmid); 571 } else if (rdtgrp->type == RDTMON_GROUP) { 572 if (rdtgrp->mon.parent->closid == tsk->closid) { 573 WRITE_ONCE(tsk->rmid, rdtgrp->mon.rmid); 574 } else { 575 rdt_last_cmd_puts("Can't move task to different control group\n"); 576 return -EINVAL; 577 } 578 } 579 580 /* 581 * Ensure the task's closid and rmid are written before determining if 582 * the task is current that will decide if it will be interrupted. 583 */ 584 barrier(); 585 586 /* 587 * By now, the task's closid and rmid are set. If the task is current 588 * on a CPU, the PQR_ASSOC MSR needs to be updated to make the resource 589 * group go into effect. If the task is not current, the MSR will be 590 * updated when the task is scheduled in. 591 */ 592 update_task_closid_rmid(tsk); 593 594 return 0; 595 } 596 597 static bool is_closid_match(struct task_struct *t, struct rdtgroup *r) 598 { 599 return (rdt_alloc_capable && 600 (r->type == RDTCTRL_GROUP) && (t->closid == r->closid)); 601 } 602 603 static bool is_rmid_match(struct task_struct *t, struct rdtgroup *r) 604 { 605 return (rdt_mon_capable && 606 (r->type == RDTMON_GROUP) && (t->rmid == r->mon.rmid)); 607 } 608 609 /** 610 * rdtgroup_tasks_assigned - Test if tasks have been assigned to resource group 611 * @r: Resource group 612 * 613 * Return: 1 if tasks have been assigned to @r, 0 otherwise 614 */ 615 int rdtgroup_tasks_assigned(struct rdtgroup *r) 616 { 617 struct task_struct *p, *t; 618 int ret = 0; 619 620 lockdep_assert_held(&rdtgroup_mutex); 621 622 rcu_read_lock(); 623 for_each_process_thread(p, t) { 624 if (is_closid_match(t, r) || is_rmid_match(t, r)) { 625 ret = 1; 626 break; 627 } 628 } 629 rcu_read_unlock(); 630 631 return ret; 632 } 633 634 static int rdtgroup_task_write_permission(struct task_struct *task, 635 struct kernfs_open_file *of) 636 { 637 const struct cred *tcred = get_task_cred(task); 638 const struct cred *cred = current_cred(); 639 int ret = 0; 640 641 /* 642 * Even if we're attaching all tasks in the thread group, we only 643 * need to check permissions on one of them. 644 */ 645 if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) && 646 !uid_eq(cred->euid, tcred->uid) && 647 !uid_eq(cred->euid, tcred->suid)) { 648 rdt_last_cmd_printf("No permission to move task %d\n", task->pid); 649 ret = -EPERM; 650 } 651 652 put_cred(tcred); 653 return ret; 654 } 655 656 static int rdtgroup_move_task(pid_t pid, struct rdtgroup *rdtgrp, 657 struct kernfs_open_file *of) 658 { 659 struct task_struct *tsk; 660 int ret; 661 662 rcu_read_lock(); 663 if (pid) { 664 tsk = find_task_by_vpid(pid); 665 if (!tsk) { 666 rcu_read_unlock(); 667 rdt_last_cmd_printf("No task %d\n", pid); 668 return -ESRCH; 669 } 670 } else { 671 tsk = current; 672 } 673 674 get_task_struct(tsk); 675 rcu_read_unlock(); 676 677 ret = rdtgroup_task_write_permission(tsk, of); 678 if (!ret) 679 ret = __rdtgroup_move_task(tsk, rdtgrp); 680 681 put_task_struct(tsk); 682 return ret; 683 } 684 685 static ssize_t rdtgroup_tasks_write(struct kernfs_open_file *of, 686 char *buf, size_t nbytes, loff_t off) 687 { 688 struct rdtgroup *rdtgrp; 689 int ret = 0; 690 pid_t pid; 691 692 if (kstrtoint(strstrip(buf), 0, &pid) || pid < 0) 693 return -EINVAL; 694 rdtgrp = rdtgroup_kn_lock_live(of->kn); 695 if (!rdtgrp) { 696 rdtgroup_kn_unlock(of->kn); 697 return -ENOENT; 698 } 699 rdt_last_cmd_clear(); 700 701 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 702 rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 703 ret = -EINVAL; 704 rdt_last_cmd_puts("Pseudo-locking in progress\n"); 705 goto unlock; 706 } 707 708 ret = rdtgroup_move_task(pid, rdtgrp, of); 709 710 unlock: 711 rdtgroup_kn_unlock(of->kn); 712 713 return ret ?: nbytes; 714 } 715 716 static void show_rdt_tasks(struct rdtgroup *r, struct seq_file *s) 717 { 718 struct task_struct *p, *t; 719 720 rcu_read_lock(); 721 for_each_process_thread(p, t) { 722 if (is_closid_match(t, r) || is_rmid_match(t, r)) 723 seq_printf(s, "%d\n", t->pid); 724 } 725 rcu_read_unlock(); 726 } 727 728 static int rdtgroup_tasks_show(struct kernfs_open_file *of, 729 struct seq_file *s, void *v) 730 { 731 struct rdtgroup *rdtgrp; 732 int ret = 0; 733 734 rdtgrp = rdtgroup_kn_lock_live(of->kn); 735 if (rdtgrp) 736 show_rdt_tasks(rdtgrp, s); 737 else 738 ret = -ENOENT; 739 rdtgroup_kn_unlock(of->kn); 740 741 return ret; 742 } 743 744 #ifdef CONFIG_PROC_CPU_RESCTRL 745 746 /* 747 * A task can only be part of one resctrl control group and of one monitor 748 * group which is associated to that control group. 749 * 750 * 1) res: 751 * mon: 752 * 753 * resctrl is not available. 754 * 755 * 2) res:/ 756 * mon: 757 * 758 * Task is part of the root resctrl control group, and it is not associated 759 * to any monitor group. 760 * 761 * 3) res:/ 762 * mon:mon0 763 * 764 * Task is part of the root resctrl control group and monitor group mon0. 765 * 766 * 4) res:group0 767 * mon: 768 * 769 * Task is part of resctrl control group group0, and it is not associated 770 * to any monitor group. 771 * 772 * 5) res:group0 773 * mon:mon1 774 * 775 * Task is part of resctrl control group group0 and monitor group mon1. 776 */ 777 int proc_resctrl_show(struct seq_file *s, struct pid_namespace *ns, 778 struct pid *pid, struct task_struct *tsk) 779 { 780 struct rdtgroup *rdtg; 781 int ret = 0; 782 783 mutex_lock(&rdtgroup_mutex); 784 785 /* Return empty if resctrl has not been mounted. */ 786 if (!static_branch_unlikely(&rdt_enable_key)) { 787 seq_puts(s, "res:\nmon:\n"); 788 goto unlock; 789 } 790 791 list_for_each_entry(rdtg, &rdt_all_groups, rdtgroup_list) { 792 struct rdtgroup *crg; 793 794 /* 795 * Task information is only relevant for shareable 796 * and exclusive groups. 797 */ 798 if (rdtg->mode != RDT_MODE_SHAREABLE && 799 rdtg->mode != RDT_MODE_EXCLUSIVE) 800 continue; 801 802 if (rdtg->closid != tsk->closid) 803 continue; 804 805 seq_printf(s, "res:%s%s\n", (rdtg == &rdtgroup_default) ? "/" : "", 806 rdtg->kn->name); 807 seq_puts(s, "mon:"); 808 list_for_each_entry(crg, &rdtg->mon.crdtgrp_list, 809 mon.crdtgrp_list) { 810 if (tsk->rmid != crg->mon.rmid) 811 continue; 812 seq_printf(s, "%s", crg->kn->name); 813 break; 814 } 815 seq_putc(s, '\n'); 816 goto unlock; 817 } 818 /* 819 * The above search should succeed. Otherwise return 820 * with an error. 821 */ 822 ret = -ENOENT; 823 unlock: 824 mutex_unlock(&rdtgroup_mutex); 825 826 return ret; 827 } 828 #endif 829 830 static int rdt_last_cmd_status_show(struct kernfs_open_file *of, 831 struct seq_file *seq, void *v) 832 { 833 int len; 834 835 mutex_lock(&rdtgroup_mutex); 836 len = seq_buf_used(&last_cmd_status); 837 if (len) 838 seq_printf(seq, "%.*s", len, last_cmd_status_buf); 839 else 840 seq_puts(seq, "ok\n"); 841 mutex_unlock(&rdtgroup_mutex); 842 return 0; 843 } 844 845 static int rdt_num_closids_show(struct kernfs_open_file *of, 846 struct seq_file *seq, void *v) 847 { 848 struct resctrl_schema *s = of->kn->parent->priv; 849 850 seq_printf(seq, "%u\n", s->num_closid); 851 return 0; 852 } 853 854 static int rdt_default_ctrl_show(struct kernfs_open_file *of, 855 struct seq_file *seq, void *v) 856 { 857 struct resctrl_schema *s = of->kn->parent->priv; 858 struct rdt_resource *r = s->res; 859 860 seq_printf(seq, "%x\n", r->default_ctrl); 861 return 0; 862 } 863 864 static int rdt_min_cbm_bits_show(struct kernfs_open_file *of, 865 struct seq_file *seq, void *v) 866 { 867 struct resctrl_schema *s = of->kn->parent->priv; 868 struct rdt_resource *r = s->res; 869 870 seq_printf(seq, "%u\n", r->cache.min_cbm_bits); 871 return 0; 872 } 873 874 static int rdt_shareable_bits_show(struct kernfs_open_file *of, 875 struct seq_file *seq, void *v) 876 { 877 struct resctrl_schema *s = of->kn->parent->priv; 878 struct rdt_resource *r = s->res; 879 880 seq_printf(seq, "%x\n", r->cache.shareable_bits); 881 return 0; 882 } 883 884 /** 885 * rdt_bit_usage_show - Display current usage of resources 886 * 887 * A domain is a shared resource that can now be allocated differently. Here 888 * we display the current regions of the domain as an annotated bitmask. 889 * For each domain of this resource its allocation bitmask 890 * is annotated as below to indicate the current usage of the corresponding bit: 891 * 0 - currently unused 892 * X - currently available for sharing and used by software and hardware 893 * H - currently used by hardware only but available for software use 894 * S - currently used and shareable by software only 895 * E - currently used exclusively by one resource group 896 * P - currently pseudo-locked by one resource group 897 */ 898 static int rdt_bit_usage_show(struct kernfs_open_file *of, 899 struct seq_file *seq, void *v) 900 { 901 struct resctrl_schema *s = of->kn->parent->priv; 902 /* 903 * Use unsigned long even though only 32 bits are used to ensure 904 * test_bit() is used safely. 905 */ 906 unsigned long sw_shareable = 0, hw_shareable = 0; 907 unsigned long exclusive = 0, pseudo_locked = 0; 908 struct rdt_resource *r = s->res; 909 struct rdt_domain *dom; 910 int i, hwb, swb, excl, psl; 911 enum rdtgrp_mode mode; 912 bool sep = false; 913 u32 ctrl_val; 914 915 mutex_lock(&rdtgroup_mutex); 916 hw_shareable = r->cache.shareable_bits; 917 list_for_each_entry(dom, &r->domains, list) { 918 if (sep) 919 seq_putc(seq, ';'); 920 sw_shareable = 0; 921 exclusive = 0; 922 seq_printf(seq, "%d=", dom->id); 923 for (i = 0; i < closids_supported(); i++) { 924 if (!closid_allocated(i)) 925 continue; 926 ctrl_val = resctrl_arch_get_config(r, dom, i, 927 s->conf_type); 928 mode = rdtgroup_mode_by_closid(i); 929 switch (mode) { 930 case RDT_MODE_SHAREABLE: 931 sw_shareable |= ctrl_val; 932 break; 933 case RDT_MODE_EXCLUSIVE: 934 exclusive |= ctrl_val; 935 break; 936 case RDT_MODE_PSEUDO_LOCKSETUP: 937 /* 938 * RDT_MODE_PSEUDO_LOCKSETUP is possible 939 * here but not included since the CBM 940 * associated with this CLOSID in this mode 941 * is not initialized and no task or cpu can be 942 * assigned this CLOSID. 943 */ 944 break; 945 case RDT_MODE_PSEUDO_LOCKED: 946 case RDT_NUM_MODES: 947 WARN(1, 948 "invalid mode for closid %d\n", i); 949 break; 950 } 951 } 952 for (i = r->cache.cbm_len - 1; i >= 0; i--) { 953 pseudo_locked = dom->plr ? dom->plr->cbm : 0; 954 hwb = test_bit(i, &hw_shareable); 955 swb = test_bit(i, &sw_shareable); 956 excl = test_bit(i, &exclusive); 957 psl = test_bit(i, &pseudo_locked); 958 if (hwb && swb) 959 seq_putc(seq, 'X'); 960 else if (hwb && !swb) 961 seq_putc(seq, 'H'); 962 else if (!hwb && swb) 963 seq_putc(seq, 'S'); 964 else if (excl) 965 seq_putc(seq, 'E'); 966 else if (psl) 967 seq_putc(seq, 'P'); 968 else /* Unused bits remain */ 969 seq_putc(seq, '0'); 970 } 971 sep = true; 972 } 973 seq_putc(seq, '\n'); 974 mutex_unlock(&rdtgroup_mutex); 975 return 0; 976 } 977 978 static int rdt_min_bw_show(struct kernfs_open_file *of, 979 struct seq_file *seq, void *v) 980 { 981 struct resctrl_schema *s = of->kn->parent->priv; 982 struct rdt_resource *r = s->res; 983 984 seq_printf(seq, "%u\n", r->membw.min_bw); 985 return 0; 986 } 987 988 static int rdt_num_rmids_show(struct kernfs_open_file *of, 989 struct seq_file *seq, void *v) 990 { 991 struct rdt_resource *r = of->kn->parent->priv; 992 993 seq_printf(seq, "%d\n", r->num_rmid); 994 995 return 0; 996 } 997 998 static int rdt_mon_features_show(struct kernfs_open_file *of, 999 struct seq_file *seq, void *v) 1000 { 1001 struct rdt_resource *r = of->kn->parent->priv; 1002 struct mon_evt *mevt; 1003 1004 list_for_each_entry(mevt, &r->evt_list, list) 1005 seq_printf(seq, "%s\n", mevt->name); 1006 1007 return 0; 1008 } 1009 1010 static int rdt_bw_gran_show(struct kernfs_open_file *of, 1011 struct seq_file *seq, void *v) 1012 { 1013 struct resctrl_schema *s = of->kn->parent->priv; 1014 struct rdt_resource *r = s->res; 1015 1016 seq_printf(seq, "%u\n", r->membw.bw_gran); 1017 return 0; 1018 } 1019 1020 static int rdt_delay_linear_show(struct kernfs_open_file *of, 1021 struct seq_file *seq, void *v) 1022 { 1023 struct resctrl_schema *s = of->kn->parent->priv; 1024 struct rdt_resource *r = s->res; 1025 1026 seq_printf(seq, "%u\n", r->membw.delay_linear); 1027 return 0; 1028 } 1029 1030 static int max_threshold_occ_show(struct kernfs_open_file *of, 1031 struct seq_file *seq, void *v) 1032 { 1033 struct rdt_resource *r = of->kn->parent->priv; 1034 struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 1035 1036 seq_printf(seq, "%u\n", resctrl_cqm_threshold * hw_res->mon_scale); 1037 1038 return 0; 1039 } 1040 1041 static int rdt_thread_throttle_mode_show(struct kernfs_open_file *of, 1042 struct seq_file *seq, void *v) 1043 { 1044 struct resctrl_schema *s = of->kn->parent->priv; 1045 struct rdt_resource *r = s->res; 1046 1047 if (r->membw.throttle_mode == THREAD_THROTTLE_PER_THREAD) 1048 seq_puts(seq, "per-thread\n"); 1049 else 1050 seq_puts(seq, "max\n"); 1051 1052 return 0; 1053 } 1054 1055 static ssize_t max_threshold_occ_write(struct kernfs_open_file *of, 1056 char *buf, size_t nbytes, loff_t off) 1057 { 1058 struct rdt_hw_resource *hw_res; 1059 unsigned int bytes; 1060 int ret; 1061 1062 ret = kstrtouint(buf, 0, &bytes); 1063 if (ret) 1064 return ret; 1065 1066 if (bytes > (boot_cpu_data.x86_cache_size * 1024)) 1067 return -EINVAL; 1068 1069 hw_res = resctrl_to_arch_res(of->kn->parent->priv); 1070 resctrl_cqm_threshold = bytes / hw_res->mon_scale; 1071 1072 return nbytes; 1073 } 1074 1075 /* 1076 * rdtgroup_mode_show - Display mode of this resource group 1077 */ 1078 static int rdtgroup_mode_show(struct kernfs_open_file *of, 1079 struct seq_file *s, void *v) 1080 { 1081 struct rdtgroup *rdtgrp; 1082 1083 rdtgrp = rdtgroup_kn_lock_live(of->kn); 1084 if (!rdtgrp) { 1085 rdtgroup_kn_unlock(of->kn); 1086 return -ENOENT; 1087 } 1088 1089 seq_printf(s, "%s\n", rdtgroup_mode_str(rdtgrp->mode)); 1090 1091 rdtgroup_kn_unlock(of->kn); 1092 return 0; 1093 } 1094 1095 static enum resctrl_conf_type resctrl_peer_type(enum resctrl_conf_type my_type) 1096 { 1097 switch (my_type) { 1098 case CDP_CODE: 1099 return CDP_DATA; 1100 case CDP_DATA: 1101 return CDP_CODE; 1102 default: 1103 case CDP_NONE: 1104 return CDP_NONE; 1105 } 1106 } 1107 1108 /** 1109 * __rdtgroup_cbm_overlaps - Does CBM for intended closid overlap with other 1110 * @r: Resource to which domain instance @d belongs. 1111 * @d: The domain instance for which @closid is being tested. 1112 * @cbm: Capacity bitmask being tested. 1113 * @closid: Intended closid for @cbm. 1114 * @exclusive: Only check if overlaps with exclusive resource groups 1115 * 1116 * Checks if provided @cbm intended to be used for @closid on domain 1117 * @d overlaps with any other closids or other hardware usage associated 1118 * with this domain. If @exclusive is true then only overlaps with 1119 * resource groups in exclusive mode will be considered. If @exclusive 1120 * is false then overlaps with any resource group or hardware entities 1121 * will be considered. 1122 * 1123 * @cbm is unsigned long, even if only 32 bits are used, to make the 1124 * bitmap functions work correctly. 1125 * 1126 * Return: false if CBM does not overlap, true if it does. 1127 */ 1128 static bool __rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d, 1129 unsigned long cbm, int closid, 1130 enum resctrl_conf_type type, bool exclusive) 1131 { 1132 enum rdtgrp_mode mode; 1133 unsigned long ctrl_b; 1134 int i; 1135 1136 /* Check for any overlap with regions used by hardware directly */ 1137 if (!exclusive) { 1138 ctrl_b = r->cache.shareable_bits; 1139 if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) 1140 return true; 1141 } 1142 1143 /* Check for overlap with other resource groups */ 1144 for (i = 0; i < closids_supported(); i++) { 1145 ctrl_b = resctrl_arch_get_config(r, d, i, type); 1146 mode = rdtgroup_mode_by_closid(i); 1147 if (closid_allocated(i) && i != closid && 1148 mode != RDT_MODE_PSEUDO_LOCKSETUP) { 1149 if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) { 1150 if (exclusive) { 1151 if (mode == RDT_MODE_EXCLUSIVE) 1152 return true; 1153 continue; 1154 } 1155 return true; 1156 } 1157 } 1158 } 1159 1160 return false; 1161 } 1162 1163 /** 1164 * rdtgroup_cbm_overlaps - Does CBM overlap with other use of hardware 1165 * @s: Schema for the resource to which domain instance @d belongs. 1166 * @d: The domain instance for which @closid is being tested. 1167 * @cbm: Capacity bitmask being tested. 1168 * @closid: Intended closid for @cbm. 1169 * @exclusive: Only check if overlaps with exclusive resource groups 1170 * 1171 * Resources that can be allocated using a CBM can use the CBM to control 1172 * the overlap of these allocations. rdtgroup_cmb_overlaps() is the test 1173 * for overlap. Overlap test is not limited to the specific resource for 1174 * which the CBM is intended though - when dealing with CDP resources that 1175 * share the underlying hardware the overlap check should be performed on 1176 * the CDP resource sharing the hardware also. 1177 * 1178 * Refer to description of __rdtgroup_cbm_overlaps() for the details of the 1179 * overlap test. 1180 * 1181 * Return: true if CBM overlap detected, false if there is no overlap 1182 */ 1183 bool rdtgroup_cbm_overlaps(struct resctrl_schema *s, struct rdt_domain *d, 1184 unsigned long cbm, int closid, bool exclusive) 1185 { 1186 enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 1187 struct rdt_resource *r = s->res; 1188 1189 if (__rdtgroup_cbm_overlaps(r, d, cbm, closid, s->conf_type, 1190 exclusive)) 1191 return true; 1192 1193 if (!resctrl_arch_get_cdp_enabled(r->rid)) 1194 return false; 1195 return __rdtgroup_cbm_overlaps(r, d, cbm, closid, peer_type, exclusive); 1196 } 1197 1198 /** 1199 * rdtgroup_mode_test_exclusive - Test if this resource group can be exclusive 1200 * 1201 * An exclusive resource group implies that there should be no sharing of 1202 * its allocated resources. At the time this group is considered to be 1203 * exclusive this test can determine if its current schemata supports this 1204 * setting by testing for overlap with all other resource groups. 1205 * 1206 * Return: true if resource group can be exclusive, false if there is overlap 1207 * with allocations of other resource groups and thus this resource group 1208 * cannot be exclusive. 1209 */ 1210 static bool rdtgroup_mode_test_exclusive(struct rdtgroup *rdtgrp) 1211 { 1212 int closid = rdtgrp->closid; 1213 struct resctrl_schema *s; 1214 struct rdt_resource *r; 1215 bool has_cache = false; 1216 struct rdt_domain *d; 1217 u32 ctrl; 1218 1219 list_for_each_entry(s, &resctrl_schema_all, list) { 1220 r = s->res; 1221 if (r->rid == RDT_RESOURCE_MBA) 1222 continue; 1223 has_cache = true; 1224 list_for_each_entry(d, &r->domains, list) { 1225 ctrl = resctrl_arch_get_config(r, d, closid, 1226 s->conf_type); 1227 if (rdtgroup_cbm_overlaps(s, d, ctrl, closid, false)) { 1228 rdt_last_cmd_puts("Schemata overlaps\n"); 1229 return false; 1230 } 1231 } 1232 } 1233 1234 if (!has_cache) { 1235 rdt_last_cmd_puts("Cannot be exclusive without CAT/CDP\n"); 1236 return false; 1237 } 1238 1239 return true; 1240 } 1241 1242 /** 1243 * rdtgroup_mode_write - Modify the resource group's mode 1244 * 1245 */ 1246 static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, 1247 char *buf, size_t nbytes, loff_t off) 1248 { 1249 struct rdtgroup *rdtgrp; 1250 enum rdtgrp_mode mode; 1251 int ret = 0; 1252 1253 /* Valid input requires a trailing newline */ 1254 if (nbytes == 0 || buf[nbytes - 1] != '\n') 1255 return -EINVAL; 1256 buf[nbytes - 1] = '\0'; 1257 1258 rdtgrp = rdtgroup_kn_lock_live(of->kn); 1259 if (!rdtgrp) { 1260 rdtgroup_kn_unlock(of->kn); 1261 return -ENOENT; 1262 } 1263 1264 rdt_last_cmd_clear(); 1265 1266 mode = rdtgrp->mode; 1267 1268 if ((!strcmp(buf, "shareable") && mode == RDT_MODE_SHAREABLE) || 1269 (!strcmp(buf, "exclusive") && mode == RDT_MODE_EXCLUSIVE) || 1270 (!strcmp(buf, "pseudo-locksetup") && 1271 mode == RDT_MODE_PSEUDO_LOCKSETUP) || 1272 (!strcmp(buf, "pseudo-locked") && mode == RDT_MODE_PSEUDO_LOCKED)) 1273 goto out; 1274 1275 if (mode == RDT_MODE_PSEUDO_LOCKED) { 1276 rdt_last_cmd_puts("Cannot change pseudo-locked group\n"); 1277 ret = -EINVAL; 1278 goto out; 1279 } 1280 1281 if (!strcmp(buf, "shareable")) { 1282 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1283 ret = rdtgroup_locksetup_exit(rdtgrp); 1284 if (ret) 1285 goto out; 1286 } 1287 rdtgrp->mode = RDT_MODE_SHAREABLE; 1288 } else if (!strcmp(buf, "exclusive")) { 1289 if (!rdtgroup_mode_test_exclusive(rdtgrp)) { 1290 ret = -EINVAL; 1291 goto out; 1292 } 1293 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1294 ret = rdtgroup_locksetup_exit(rdtgrp); 1295 if (ret) 1296 goto out; 1297 } 1298 rdtgrp->mode = RDT_MODE_EXCLUSIVE; 1299 } else if (!strcmp(buf, "pseudo-locksetup")) { 1300 ret = rdtgroup_locksetup_enter(rdtgrp); 1301 if (ret) 1302 goto out; 1303 rdtgrp->mode = RDT_MODE_PSEUDO_LOCKSETUP; 1304 } else { 1305 rdt_last_cmd_puts("Unknown or unsupported mode\n"); 1306 ret = -EINVAL; 1307 } 1308 1309 out: 1310 rdtgroup_kn_unlock(of->kn); 1311 return ret ?: nbytes; 1312 } 1313 1314 /** 1315 * rdtgroup_cbm_to_size - Translate CBM to size in bytes 1316 * @r: RDT resource to which @d belongs. 1317 * @d: RDT domain instance. 1318 * @cbm: bitmask for which the size should be computed. 1319 * 1320 * The bitmask provided associated with the RDT domain instance @d will be 1321 * translated into how many bytes it represents. The size in bytes is 1322 * computed by first dividing the total cache size by the CBM length to 1323 * determine how many bytes each bit in the bitmask represents. The result 1324 * is multiplied with the number of bits set in the bitmask. 1325 * 1326 * @cbm is unsigned long, even if only 32 bits are used to make the 1327 * bitmap functions work correctly. 1328 */ 1329 unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, 1330 struct rdt_domain *d, unsigned long cbm) 1331 { 1332 struct cpu_cacheinfo *ci; 1333 unsigned int size = 0; 1334 int num_b, i; 1335 1336 num_b = bitmap_weight(&cbm, r->cache.cbm_len); 1337 ci = get_cpu_cacheinfo(cpumask_any(&d->cpu_mask)); 1338 for (i = 0; i < ci->num_leaves; i++) { 1339 if (ci->info_list[i].level == r->cache_level) { 1340 size = ci->info_list[i].size / r->cache.cbm_len * num_b; 1341 break; 1342 } 1343 } 1344 1345 return size; 1346 } 1347 1348 /** 1349 * rdtgroup_size_show - Display size in bytes of allocated regions 1350 * 1351 * The "size" file mirrors the layout of the "schemata" file, printing the 1352 * size in bytes of each region instead of the capacity bitmask. 1353 * 1354 */ 1355 static int rdtgroup_size_show(struct kernfs_open_file *of, 1356 struct seq_file *s, void *v) 1357 { 1358 struct resctrl_schema *schema; 1359 enum resctrl_conf_type type; 1360 struct rdtgroup *rdtgrp; 1361 struct rdt_resource *r; 1362 struct rdt_domain *d; 1363 unsigned int size; 1364 int ret = 0; 1365 u32 closid; 1366 bool sep; 1367 u32 ctrl; 1368 1369 rdtgrp = rdtgroup_kn_lock_live(of->kn); 1370 if (!rdtgrp) { 1371 rdtgroup_kn_unlock(of->kn); 1372 return -ENOENT; 1373 } 1374 1375 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 1376 if (!rdtgrp->plr->d) { 1377 rdt_last_cmd_clear(); 1378 rdt_last_cmd_puts("Cache domain offline\n"); 1379 ret = -ENODEV; 1380 } else { 1381 seq_printf(s, "%*s:", max_name_width, 1382 rdtgrp->plr->s->name); 1383 size = rdtgroup_cbm_to_size(rdtgrp->plr->s->res, 1384 rdtgrp->plr->d, 1385 rdtgrp->plr->cbm); 1386 seq_printf(s, "%d=%u\n", rdtgrp->plr->d->id, size); 1387 } 1388 goto out; 1389 } 1390 1391 closid = rdtgrp->closid; 1392 1393 list_for_each_entry(schema, &resctrl_schema_all, list) { 1394 r = schema->res; 1395 type = schema->conf_type; 1396 sep = false; 1397 seq_printf(s, "%*s:", max_name_width, schema->name); 1398 list_for_each_entry(d, &r->domains, list) { 1399 if (sep) 1400 seq_putc(s, ';'); 1401 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1402 size = 0; 1403 } else { 1404 if (is_mba_sc(r)) 1405 ctrl = d->mbps_val[closid]; 1406 else 1407 ctrl = resctrl_arch_get_config(r, d, 1408 closid, 1409 type); 1410 if (r->rid == RDT_RESOURCE_MBA) 1411 size = ctrl; 1412 else 1413 size = rdtgroup_cbm_to_size(r, d, ctrl); 1414 } 1415 seq_printf(s, "%d=%u", d->id, size); 1416 sep = true; 1417 } 1418 seq_putc(s, '\n'); 1419 } 1420 1421 out: 1422 rdtgroup_kn_unlock(of->kn); 1423 1424 return ret; 1425 } 1426 1427 /* rdtgroup information files for one cache resource. */ 1428 static struct rftype res_common_files[] = { 1429 { 1430 .name = "last_cmd_status", 1431 .mode = 0444, 1432 .kf_ops = &rdtgroup_kf_single_ops, 1433 .seq_show = rdt_last_cmd_status_show, 1434 .fflags = RF_TOP_INFO, 1435 }, 1436 { 1437 .name = "num_closids", 1438 .mode = 0444, 1439 .kf_ops = &rdtgroup_kf_single_ops, 1440 .seq_show = rdt_num_closids_show, 1441 .fflags = RF_CTRL_INFO, 1442 }, 1443 { 1444 .name = "mon_features", 1445 .mode = 0444, 1446 .kf_ops = &rdtgroup_kf_single_ops, 1447 .seq_show = rdt_mon_features_show, 1448 .fflags = RF_MON_INFO, 1449 }, 1450 { 1451 .name = "num_rmids", 1452 .mode = 0444, 1453 .kf_ops = &rdtgroup_kf_single_ops, 1454 .seq_show = rdt_num_rmids_show, 1455 .fflags = RF_MON_INFO, 1456 }, 1457 { 1458 .name = "cbm_mask", 1459 .mode = 0444, 1460 .kf_ops = &rdtgroup_kf_single_ops, 1461 .seq_show = rdt_default_ctrl_show, 1462 .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1463 }, 1464 { 1465 .name = "min_cbm_bits", 1466 .mode = 0444, 1467 .kf_ops = &rdtgroup_kf_single_ops, 1468 .seq_show = rdt_min_cbm_bits_show, 1469 .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1470 }, 1471 { 1472 .name = "shareable_bits", 1473 .mode = 0444, 1474 .kf_ops = &rdtgroup_kf_single_ops, 1475 .seq_show = rdt_shareable_bits_show, 1476 .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1477 }, 1478 { 1479 .name = "bit_usage", 1480 .mode = 0444, 1481 .kf_ops = &rdtgroup_kf_single_ops, 1482 .seq_show = rdt_bit_usage_show, 1483 .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1484 }, 1485 { 1486 .name = "min_bandwidth", 1487 .mode = 0444, 1488 .kf_ops = &rdtgroup_kf_single_ops, 1489 .seq_show = rdt_min_bw_show, 1490 .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1491 }, 1492 { 1493 .name = "bandwidth_gran", 1494 .mode = 0444, 1495 .kf_ops = &rdtgroup_kf_single_ops, 1496 .seq_show = rdt_bw_gran_show, 1497 .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1498 }, 1499 { 1500 .name = "delay_linear", 1501 .mode = 0444, 1502 .kf_ops = &rdtgroup_kf_single_ops, 1503 .seq_show = rdt_delay_linear_show, 1504 .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1505 }, 1506 /* 1507 * Platform specific which (if any) capabilities are provided by 1508 * thread_throttle_mode. Defer "fflags" initialization to platform 1509 * discovery. 1510 */ 1511 { 1512 .name = "thread_throttle_mode", 1513 .mode = 0444, 1514 .kf_ops = &rdtgroup_kf_single_ops, 1515 .seq_show = rdt_thread_throttle_mode_show, 1516 }, 1517 { 1518 .name = "max_threshold_occupancy", 1519 .mode = 0644, 1520 .kf_ops = &rdtgroup_kf_single_ops, 1521 .write = max_threshold_occ_write, 1522 .seq_show = max_threshold_occ_show, 1523 .fflags = RF_MON_INFO | RFTYPE_RES_CACHE, 1524 }, 1525 { 1526 .name = "cpus", 1527 .mode = 0644, 1528 .kf_ops = &rdtgroup_kf_single_ops, 1529 .write = rdtgroup_cpus_write, 1530 .seq_show = rdtgroup_cpus_show, 1531 .fflags = RFTYPE_BASE, 1532 }, 1533 { 1534 .name = "cpus_list", 1535 .mode = 0644, 1536 .kf_ops = &rdtgroup_kf_single_ops, 1537 .write = rdtgroup_cpus_write, 1538 .seq_show = rdtgroup_cpus_show, 1539 .flags = RFTYPE_FLAGS_CPUS_LIST, 1540 .fflags = RFTYPE_BASE, 1541 }, 1542 { 1543 .name = "tasks", 1544 .mode = 0644, 1545 .kf_ops = &rdtgroup_kf_single_ops, 1546 .write = rdtgroup_tasks_write, 1547 .seq_show = rdtgroup_tasks_show, 1548 .fflags = RFTYPE_BASE, 1549 }, 1550 { 1551 .name = "schemata", 1552 .mode = 0644, 1553 .kf_ops = &rdtgroup_kf_single_ops, 1554 .write = rdtgroup_schemata_write, 1555 .seq_show = rdtgroup_schemata_show, 1556 .fflags = RF_CTRL_BASE, 1557 }, 1558 { 1559 .name = "mode", 1560 .mode = 0644, 1561 .kf_ops = &rdtgroup_kf_single_ops, 1562 .write = rdtgroup_mode_write, 1563 .seq_show = rdtgroup_mode_show, 1564 .fflags = RF_CTRL_BASE, 1565 }, 1566 { 1567 .name = "size", 1568 .mode = 0444, 1569 .kf_ops = &rdtgroup_kf_single_ops, 1570 .seq_show = rdtgroup_size_show, 1571 .fflags = RF_CTRL_BASE, 1572 }, 1573 1574 }; 1575 1576 static int rdtgroup_add_files(struct kernfs_node *kn, unsigned long fflags) 1577 { 1578 struct rftype *rfts, *rft; 1579 int ret, len; 1580 1581 rfts = res_common_files; 1582 len = ARRAY_SIZE(res_common_files); 1583 1584 lockdep_assert_held(&rdtgroup_mutex); 1585 1586 for (rft = rfts; rft < rfts + len; rft++) { 1587 if (rft->fflags && ((fflags & rft->fflags) == rft->fflags)) { 1588 ret = rdtgroup_add_file(kn, rft); 1589 if (ret) 1590 goto error; 1591 } 1592 } 1593 1594 return 0; 1595 error: 1596 pr_warn("Failed to add %s, err=%d\n", rft->name, ret); 1597 while (--rft >= rfts) { 1598 if ((fflags & rft->fflags) == rft->fflags) 1599 kernfs_remove_by_name(kn, rft->name); 1600 } 1601 return ret; 1602 } 1603 1604 static struct rftype *rdtgroup_get_rftype_by_name(const char *name) 1605 { 1606 struct rftype *rfts, *rft; 1607 int len; 1608 1609 rfts = res_common_files; 1610 len = ARRAY_SIZE(res_common_files); 1611 1612 for (rft = rfts; rft < rfts + len; rft++) { 1613 if (!strcmp(rft->name, name)) 1614 return rft; 1615 } 1616 1617 return NULL; 1618 } 1619 1620 void __init thread_throttle_mode_init(void) 1621 { 1622 struct rftype *rft; 1623 1624 rft = rdtgroup_get_rftype_by_name("thread_throttle_mode"); 1625 if (!rft) 1626 return; 1627 1628 rft->fflags = RF_CTRL_INFO | RFTYPE_RES_MB; 1629 } 1630 1631 /** 1632 * rdtgroup_kn_mode_restrict - Restrict user access to named resctrl file 1633 * @r: The resource group with which the file is associated. 1634 * @name: Name of the file 1635 * 1636 * The permissions of named resctrl file, directory, or link are modified 1637 * to not allow read, write, or execute by any user. 1638 * 1639 * WARNING: This function is intended to communicate to the user that the 1640 * resctrl file has been locked down - that it is not relevant to the 1641 * particular state the system finds itself in. It should not be relied 1642 * on to protect from user access because after the file's permissions 1643 * are restricted the user can still change the permissions using chmod 1644 * from the command line. 1645 * 1646 * Return: 0 on success, <0 on failure. 1647 */ 1648 int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name) 1649 { 1650 struct iattr iattr = {.ia_valid = ATTR_MODE,}; 1651 struct kernfs_node *kn; 1652 int ret = 0; 1653 1654 kn = kernfs_find_and_get_ns(r->kn, name, NULL); 1655 if (!kn) 1656 return -ENOENT; 1657 1658 switch (kernfs_type(kn)) { 1659 case KERNFS_DIR: 1660 iattr.ia_mode = S_IFDIR; 1661 break; 1662 case KERNFS_FILE: 1663 iattr.ia_mode = S_IFREG; 1664 break; 1665 case KERNFS_LINK: 1666 iattr.ia_mode = S_IFLNK; 1667 break; 1668 } 1669 1670 ret = kernfs_setattr(kn, &iattr); 1671 kernfs_put(kn); 1672 return ret; 1673 } 1674 1675 /** 1676 * rdtgroup_kn_mode_restore - Restore user access to named resctrl file 1677 * @r: The resource group with which the file is associated. 1678 * @name: Name of the file 1679 * @mask: Mask of permissions that should be restored 1680 * 1681 * Restore the permissions of the named file. If @name is a directory the 1682 * permissions of its parent will be used. 1683 * 1684 * Return: 0 on success, <0 on failure. 1685 */ 1686 int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, 1687 umode_t mask) 1688 { 1689 struct iattr iattr = {.ia_valid = ATTR_MODE,}; 1690 struct kernfs_node *kn, *parent; 1691 struct rftype *rfts, *rft; 1692 int ret, len; 1693 1694 rfts = res_common_files; 1695 len = ARRAY_SIZE(res_common_files); 1696 1697 for (rft = rfts; rft < rfts + len; rft++) { 1698 if (!strcmp(rft->name, name)) 1699 iattr.ia_mode = rft->mode & mask; 1700 } 1701 1702 kn = kernfs_find_and_get_ns(r->kn, name, NULL); 1703 if (!kn) 1704 return -ENOENT; 1705 1706 switch (kernfs_type(kn)) { 1707 case KERNFS_DIR: 1708 parent = kernfs_get_parent(kn); 1709 if (parent) { 1710 iattr.ia_mode |= parent->mode; 1711 kernfs_put(parent); 1712 } 1713 iattr.ia_mode |= S_IFDIR; 1714 break; 1715 case KERNFS_FILE: 1716 iattr.ia_mode |= S_IFREG; 1717 break; 1718 case KERNFS_LINK: 1719 iattr.ia_mode |= S_IFLNK; 1720 break; 1721 } 1722 1723 ret = kernfs_setattr(kn, &iattr); 1724 kernfs_put(kn); 1725 return ret; 1726 } 1727 1728 static int rdtgroup_mkdir_info_resdir(void *priv, char *name, 1729 unsigned long fflags) 1730 { 1731 struct kernfs_node *kn_subdir; 1732 int ret; 1733 1734 kn_subdir = kernfs_create_dir(kn_info, name, 1735 kn_info->mode, priv); 1736 if (IS_ERR(kn_subdir)) 1737 return PTR_ERR(kn_subdir); 1738 1739 ret = rdtgroup_kn_set_ugid(kn_subdir); 1740 if (ret) 1741 return ret; 1742 1743 ret = rdtgroup_add_files(kn_subdir, fflags); 1744 if (!ret) 1745 kernfs_activate(kn_subdir); 1746 1747 return ret; 1748 } 1749 1750 static int rdtgroup_create_info_dir(struct kernfs_node *parent_kn) 1751 { 1752 struct resctrl_schema *s; 1753 struct rdt_resource *r; 1754 unsigned long fflags; 1755 char name[32]; 1756 int ret; 1757 1758 /* create the directory */ 1759 kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL); 1760 if (IS_ERR(kn_info)) 1761 return PTR_ERR(kn_info); 1762 1763 ret = rdtgroup_add_files(kn_info, RF_TOP_INFO); 1764 if (ret) 1765 goto out_destroy; 1766 1767 /* loop over enabled controls, these are all alloc_capable */ 1768 list_for_each_entry(s, &resctrl_schema_all, list) { 1769 r = s->res; 1770 fflags = r->fflags | RF_CTRL_INFO; 1771 ret = rdtgroup_mkdir_info_resdir(s, s->name, fflags); 1772 if (ret) 1773 goto out_destroy; 1774 } 1775 1776 for_each_mon_capable_rdt_resource(r) { 1777 fflags = r->fflags | RF_MON_INFO; 1778 sprintf(name, "%s_MON", r->name); 1779 ret = rdtgroup_mkdir_info_resdir(r, name, fflags); 1780 if (ret) 1781 goto out_destroy; 1782 } 1783 1784 ret = rdtgroup_kn_set_ugid(kn_info); 1785 if (ret) 1786 goto out_destroy; 1787 1788 kernfs_activate(kn_info); 1789 1790 return 0; 1791 1792 out_destroy: 1793 kernfs_remove(kn_info); 1794 return ret; 1795 } 1796 1797 static int 1798 mongroup_create_dir(struct kernfs_node *parent_kn, struct rdtgroup *prgrp, 1799 char *name, struct kernfs_node **dest_kn) 1800 { 1801 struct kernfs_node *kn; 1802 int ret; 1803 1804 /* create the directory */ 1805 kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 1806 if (IS_ERR(kn)) 1807 return PTR_ERR(kn); 1808 1809 if (dest_kn) 1810 *dest_kn = kn; 1811 1812 ret = rdtgroup_kn_set_ugid(kn); 1813 if (ret) 1814 goto out_destroy; 1815 1816 kernfs_activate(kn); 1817 1818 return 0; 1819 1820 out_destroy: 1821 kernfs_remove(kn); 1822 return ret; 1823 } 1824 1825 static void l3_qos_cfg_update(void *arg) 1826 { 1827 bool *enable = arg; 1828 1829 wrmsrl(MSR_IA32_L3_QOS_CFG, *enable ? L3_QOS_CDP_ENABLE : 0ULL); 1830 } 1831 1832 static void l2_qos_cfg_update(void *arg) 1833 { 1834 bool *enable = arg; 1835 1836 wrmsrl(MSR_IA32_L2_QOS_CFG, *enable ? L2_QOS_CDP_ENABLE : 0ULL); 1837 } 1838 1839 static inline bool is_mba_linear(void) 1840 { 1841 return rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl.membw.delay_linear; 1842 } 1843 1844 static int set_cache_qos_cfg(int level, bool enable) 1845 { 1846 void (*update)(void *arg); 1847 struct rdt_resource *r_l; 1848 cpumask_var_t cpu_mask; 1849 struct rdt_domain *d; 1850 int cpu; 1851 1852 if (level == RDT_RESOURCE_L3) 1853 update = l3_qos_cfg_update; 1854 else if (level == RDT_RESOURCE_L2) 1855 update = l2_qos_cfg_update; 1856 else 1857 return -EINVAL; 1858 1859 if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL)) 1860 return -ENOMEM; 1861 1862 r_l = &rdt_resources_all[level].r_resctrl; 1863 list_for_each_entry(d, &r_l->domains, list) { 1864 if (r_l->cache.arch_has_per_cpu_cfg) 1865 /* Pick all the CPUs in the domain instance */ 1866 for_each_cpu(cpu, &d->cpu_mask) 1867 cpumask_set_cpu(cpu, cpu_mask); 1868 else 1869 /* Pick one CPU from each domain instance to update MSR */ 1870 cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask); 1871 } 1872 cpu = get_cpu(); 1873 /* Update QOS_CFG MSR on this cpu if it's in cpu_mask. */ 1874 if (cpumask_test_cpu(cpu, cpu_mask)) 1875 update(&enable); 1876 /* Update QOS_CFG MSR on all other cpus in cpu_mask. */ 1877 smp_call_function_many(cpu_mask, update, &enable, 1); 1878 put_cpu(); 1879 1880 free_cpumask_var(cpu_mask); 1881 1882 return 0; 1883 } 1884 1885 /* Restore the qos cfg state when a domain comes online */ 1886 void rdt_domain_reconfigure_cdp(struct rdt_resource *r) 1887 { 1888 struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 1889 1890 if (!r->cdp_capable) 1891 return; 1892 1893 if (r->rid == RDT_RESOURCE_L2) 1894 l2_qos_cfg_update(&hw_res->cdp_enabled); 1895 1896 if (r->rid == RDT_RESOURCE_L3) 1897 l3_qos_cfg_update(&hw_res->cdp_enabled); 1898 } 1899 1900 static int mba_sc_domain_allocate(struct rdt_resource *r, struct rdt_domain *d) 1901 { 1902 u32 num_closid = resctrl_arch_get_num_closid(r); 1903 int cpu = cpumask_any(&d->cpu_mask); 1904 int i; 1905 1906 d->mbps_val = kcalloc_node(num_closid, sizeof(*d->mbps_val), 1907 GFP_KERNEL, cpu_to_node(cpu)); 1908 if (!d->mbps_val) 1909 return -ENOMEM; 1910 1911 for (i = 0; i < num_closid; i++) 1912 d->mbps_val[i] = MBA_MAX_MBPS; 1913 1914 return 0; 1915 } 1916 1917 static void mba_sc_domain_destroy(struct rdt_resource *r, 1918 struct rdt_domain *d) 1919 { 1920 kfree(d->mbps_val); 1921 d->mbps_val = NULL; 1922 } 1923 1924 /* 1925 * MBA software controller is supported only if 1926 * MBM is supported and MBA is in linear scale. 1927 */ 1928 static bool supports_mba_mbps(void) 1929 { 1930 struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl; 1931 1932 return (is_mbm_local_enabled() && 1933 r->alloc_capable && is_mba_linear()); 1934 } 1935 1936 /* 1937 * Enable or disable the MBA software controller 1938 * which helps user specify bandwidth in MBps. 1939 */ 1940 static int set_mba_sc(bool mba_sc) 1941 { 1942 struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl; 1943 u32 num_closid = resctrl_arch_get_num_closid(r); 1944 struct rdt_domain *d; 1945 int i; 1946 1947 if (!supports_mba_mbps() || mba_sc == is_mba_sc(r)) 1948 return -EINVAL; 1949 1950 r->membw.mba_sc = mba_sc; 1951 1952 list_for_each_entry(d, &r->domains, list) { 1953 for (i = 0; i < num_closid; i++) 1954 d->mbps_val[i] = MBA_MAX_MBPS; 1955 } 1956 1957 return 0; 1958 } 1959 1960 static int cdp_enable(int level) 1961 { 1962 struct rdt_resource *r_l = &rdt_resources_all[level].r_resctrl; 1963 int ret; 1964 1965 if (!r_l->alloc_capable) 1966 return -EINVAL; 1967 1968 ret = set_cache_qos_cfg(level, true); 1969 if (!ret) 1970 rdt_resources_all[level].cdp_enabled = true; 1971 1972 return ret; 1973 } 1974 1975 static void cdp_disable(int level) 1976 { 1977 struct rdt_hw_resource *r_hw = &rdt_resources_all[level]; 1978 1979 if (r_hw->cdp_enabled) { 1980 set_cache_qos_cfg(level, false); 1981 r_hw->cdp_enabled = false; 1982 } 1983 } 1984 1985 int resctrl_arch_set_cdp_enabled(enum resctrl_res_level l, bool enable) 1986 { 1987 struct rdt_hw_resource *hw_res = &rdt_resources_all[l]; 1988 1989 if (!hw_res->r_resctrl.cdp_capable) 1990 return -EINVAL; 1991 1992 if (enable) 1993 return cdp_enable(l); 1994 1995 cdp_disable(l); 1996 1997 return 0; 1998 } 1999 2000 static void cdp_disable_all(void) 2001 { 2002 if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3)) 2003 resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, false); 2004 if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) 2005 resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, false); 2006 } 2007 2008 /* 2009 * We don't allow rdtgroup directories to be created anywhere 2010 * except the root directory. Thus when looking for the rdtgroup 2011 * structure for a kernfs node we are either looking at a directory, 2012 * in which case the rdtgroup structure is pointed at by the "priv" 2013 * field, otherwise we have a file, and need only look to the parent 2014 * to find the rdtgroup. 2015 */ 2016 static struct rdtgroup *kernfs_to_rdtgroup(struct kernfs_node *kn) 2017 { 2018 if (kernfs_type(kn) == KERNFS_DIR) { 2019 /* 2020 * All the resource directories use "kn->priv" 2021 * to point to the "struct rdtgroup" for the 2022 * resource. "info" and its subdirectories don't 2023 * have rdtgroup structures, so return NULL here. 2024 */ 2025 if (kn == kn_info || kn->parent == kn_info) 2026 return NULL; 2027 else 2028 return kn->priv; 2029 } else { 2030 return kn->parent->priv; 2031 } 2032 } 2033 2034 struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn) 2035 { 2036 struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2037 2038 if (!rdtgrp) 2039 return NULL; 2040 2041 atomic_inc(&rdtgrp->waitcount); 2042 kernfs_break_active_protection(kn); 2043 2044 mutex_lock(&rdtgroup_mutex); 2045 2046 /* Was this group deleted while we waited? */ 2047 if (rdtgrp->flags & RDT_DELETED) 2048 return NULL; 2049 2050 return rdtgrp; 2051 } 2052 2053 void rdtgroup_kn_unlock(struct kernfs_node *kn) 2054 { 2055 struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2056 2057 if (!rdtgrp) 2058 return; 2059 2060 mutex_unlock(&rdtgroup_mutex); 2061 2062 if (atomic_dec_and_test(&rdtgrp->waitcount) && 2063 (rdtgrp->flags & RDT_DELETED)) { 2064 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2065 rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2066 rdtgroup_pseudo_lock_remove(rdtgrp); 2067 kernfs_unbreak_active_protection(kn); 2068 rdtgroup_remove(rdtgrp); 2069 } else { 2070 kernfs_unbreak_active_protection(kn); 2071 } 2072 } 2073 2074 static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2075 struct rdtgroup *prgrp, 2076 struct kernfs_node **mon_data_kn); 2077 2078 static int rdt_enable_ctx(struct rdt_fs_context *ctx) 2079 { 2080 int ret = 0; 2081 2082 if (ctx->enable_cdpl2) 2083 ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, true); 2084 2085 if (!ret && ctx->enable_cdpl3) 2086 ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, true); 2087 2088 if (!ret && ctx->enable_mba_mbps) 2089 ret = set_mba_sc(true); 2090 2091 return ret; 2092 } 2093 2094 static int schemata_list_add(struct rdt_resource *r, enum resctrl_conf_type type) 2095 { 2096 struct resctrl_schema *s; 2097 const char *suffix = ""; 2098 int ret, cl; 2099 2100 s = kzalloc(sizeof(*s), GFP_KERNEL); 2101 if (!s) 2102 return -ENOMEM; 2103 2104 s->res = r; 2105 s->num_closid = resctrl_arch_get_num_closid(r); 2106 if (resctrl_arch_get_cdp_enabled(r->rid)) 2107 s->num_closid /= 2; 2108 2109 s->conf_type = type; 2110 switch (type) { 2111 case CDP_CODE: 2112 suffix = "CODE"; 2113 break; 2114 case CDP_DATA: 2115 suffix = "DATA"; 2116 break; 2117 case CDP_NONE: 2118 suffix = ""; 2119 break; 2120 } 2121 2122 ret = snprintf(s->name, sizeof(s->name), "%s%s", r->name, suffix); 2123 if (ret >= sizeof(s->name)) { 2124 kfree(s); 2125 return -EINVAL; 2126 } 2127 2128 cl = strlen(s->name); 2129 2130 /* 2131 * If CDP is supported by this resource, but not enabled, 2132 * include the suffix. This ensures the tabular format of the 2133 * schemata file does not change between mounts of the filesystem. 2134 */ 2135 if (r->cdp_capable && !resctrl_arch_get_cdp_enabled(r->rid)) 2136 cl += 4; 2137 2138 if (cl > max_name_width) 2139 max_name_width = cl; 2140 2141 INIT_LIST_HEAD(&s->list); 2142 list_add(&s->list, &resctrl_schema_all); 2143 2144 return 0; 2145 } 2146 2147 static int schemata_list_create(void) 2148 { 2149 struct rdt_resource *r; 2150 int ret = 0; 2151 2152 for_each_alloc_capable_rdt_resource(r) { 2153 if (resctrl_arch_get_cdp_enabled(r->rid)) { 2154 ret = schemata_list_add(r, CDP_CODE); 2155 if (ret) 2156 break; 2157 2158 ret = schemata_list_add(r, CDP_DATA); 2159 } else { 2160 ret = schemata_list_add(r, CDP_NONE); 2161 } 2162 2163 if (ret) 2164 break; 2165 } 2166 2167 return ret; 2168 } 2169 2170 static void schemata_list_destroy(void) 2171 { 2172 struct resctrl_schema *s, *tmp; 2173 2174 list_for_each_entry_safe(s, tmp, &resctrl_schema_all, list) { 2175 list_del(&s->list); 2176 kfree(s); 2177 } 2178 } 2179 2180 static int rdt_get_tree(struct fs_context *fc) 2181 { 2182 struct rdt_fs_context *ctx = rdt_fc2context(fc); 2183 struct rdt_domain *dom; 2184 struct rdt_resource *r; 2185 int ret; 2186 2187 cpus_read_lock(); 2188 mutex_lock(&rdtgroup_mutex); 2189 /* 2190 * resctrl file system can only be mounted once. 2191 */ 2192 if (static_branch_unlikely(&rdt_enable_key)) { 2193 ret = -EBUSY; 2194 goto out; 2195 } 2196 2197 ret = rdt_enable_ctx(ctx); 2198 if (ret < 0) 2199 goto out_cdp; 2200 2201 ret = schemata_list_create(); 2202 if (ret) { 2203 schemata_list_destroy(); 2204 goto out_mba; 2205 } 2206 2207 closid_init(); 2208 2209 ret = rdtgroup_create_info_dir(rdtgroup_default.kn); 2210 if (ret < 0) 2211 goto out_schemata_free; 2212 2213 if (rdt_mon_capable) { 2214 ret = mongroup_create_dir(rdtgroup_default.kn, 2215 &rdtgroup_default, "mon_groups", 2216 &kn_mongrp); 2217 if (ret < 0) 2218 goto out_info; 2219 2220 ret = mkdir_mondata_all(rdtgroup_default.kn, 2221 &rdtgroup_default, &kn_mondata); 2222 if (ret < 0) 2223 goto out_mongrp; 2224 rdtgroup_default.mon.mon_data_kn = kn_mondata; 2225 } 2226 2227 ret = rdt_pseudo_lock_init(); 2228 if (ret) 2229 goto out_mondata; 2230 2231 ret = kernfs_get_tree(fc); 2232 if (ret < 0) 2233 goto out_psl; 2234 2235 if (rdt_alloc_capable) 2236 static_branch_enable_cpuslocked(&rdt_alloc_enable_key); 2237 if (rdt_mon_capable) 2238 static_branch_enable_cpuslocked(&rdt_mon_enable_key); 2239 2240 if (rdt_alloc_capable || rdt_mon_capable) 2241 static_branch_enable_cpuslocked(&rdt_enable_key); 2242 2243 if (is_mbm_enabled()) { 2244 r = &rdt_resources_all[RDT_RESOURCE_L3].r_resctrl; 2245 list_for_each_entry(dom, &r->domains, list) 2246 mbm_setup_overflow_handler(dom, MBM_OVERFLOW_INTERVAL); 2247 } 2248 2249 goto out; 2250 2251 out_psl: 2252 rdt_pseudo_lock_release(); 2253 out_mondata: 2254 if (rdt_mon_capable) 2255 kernfs_remove(kn_mondata); 2256 out_mongrp: 2257 if (rdt_mon_capable) 2258 kernfs_remove(kn_mongrp); 2259 out_info: 2260 kernfs_remove(kn_info); 2261 out_schemata_free: 2262 schemata_list_destroy(); 2263 out_mba: 2264 if (ctx->enable_mba_mbps) 2265 set_mba_sc(false); 2266 out_cdp: 2267 cdp_disable_all(); 2268 out: 2269 rdt_last_cmd_clear(); 2270 mutex_unlock(&rdtgroup_mutex); 2271 cpus_read_unlock(); 2272 return ret; 2273 } 2274 2275 enum rdt_param { 2276 Opt_cdp, 2277 Opt_cdpl2, 2278 Opt_mba_mbps, 2279 nr__rdt_params 2280 }; 2281 2282 static const struct fs_parameter_spec rdt_fs_parameters[] = { 2283 fsparam_flag("cdp", Opt_cdp), 2284 fsparam_flag("cdpl2", Opt_cdpl2), 2285 fsparam_flag("mba_MBps", Opt_mba_mbps), 2286 {} 2287 }; 2288 2289 static int rdt_parse_param(struct fs_context *fc, struct fs_parameter *param) 2290 { 2291 struct rdt_fs_context *ctx = rdt_fc2context(fc); 2292 struct fs_parse_result result; 2293 int opt; 2294 2295 opt = fs_parse(fc, rdt_fs_parameters, param, &result); 2296 if (opt < 0) 2297 return opt; 2298 2299 switch (opt) { 2300 case Opt_cdp: 2301 ctx->enable_cdpl3 = true; 2302 return 0; 2303 case Opt_cdpl2: 2304 ctx->enable_cdpl2 = true; 2305 return 0; 2306 case Opt_mba_mbps: 2307 if (!supports_mba_mbps()) 2308 return -EINVAL; 2309 ctx->enable_mba_mbps = true; 2310 return 0; 2311 } 2312 2313 return -EINVAL; 2314 } 2315 2316 static void rdt_fs_context_free(struct fs_context *fc) 2317 { 2318 struct rdt_fs_context *ctx = rdt_fc2context(fc); 2319 2320 kernfs_free_fs_context(fc); 2321 kfree(ctx); 2322 } 2323 2324 static const struct fs_context_operations rdt_fs_context_ops = { 2325 .free = rdt_fs_context_free, 2326 .parse_param = rdt_parse_param, 2327 .get_tree = rdt_get_tree, 2328 }; 2329 2330 static int rdt_init_fs_context(struct fs_context *fc) 2331 { 2332 struct rdt_fs_context *ctx; 2333 2334 ctx = kzalloc(sizeof(struct rdt_fs_context), GFP_KERNEL); 2335 if (!ctx) 2336 return -ENOMEM; 2337 2338 ctx->kfc.root = rdt_root; 2339 ctx->kfc.magic = RDTGROUP_SUPER_MAGIC; 2340 fc->fs_private = &ctx->kfc; 2341 fc->ops = &rdt_fs_context_ops; 2342 put_user_ns(fc->user_ns); 2343 fc->user_ns = get_user_ns(&init_user_ns); 2344 fc->global = true; 2345 return 0; 2346 } 2347 2348 static int reset_all_ctrls(struct rdt_resource *r) 2349 { 2350 struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 2351 struct rdt_hw_domain *hw_dom; 2352 struct msr_param msr_param; 2353 cpumask_var_t cpu_mask; 2354 struct rdt_domain *d; 2355 int i, cpu; 2356 2357 if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL)) 2358 return -ENOMEM; 2359 2360 msr_param.res = r; 2361 msr_param.low = 0; 2362 msr_param.high = hw_res->num_closid; 2363 2364 /* 2365 * Disable resource control for this resource by setting all 2366 * CBMs in all domains to the maximum mask value. Pick one CPU 2367 * from each domain to update the MSRs below. 2368 */ 2369 list_for_each_entry(d, &r->domains, list) { 2370 hw_dom = resctrl_to_arch_dom(d); 2371 cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask); 2372 2373 for (i = 0; i < hw_res->num_closid; i++) { 2374 hw_dom->ctrl_val[i] = r->default_ctrl; 2375 hw_dom->mbps_val[i] = MBA_MAX_MBPS; 2376 } 2377 } 2378 cpu = get_cpu(); 2379 /* Update CBM on this cpu if it's in cpu_mask. */ 2380 if (cpumask_test_cpu(cpu, cpu_mask)) 2381 rdt_ctrl_update(&msr_param); 2382 /* Update CBM on all other cpus in cpu_mask. */ 2383 smp_call_function_many(cpu_mask, rdt_ctrl_update, &msr_param, 1); 2384 put_cpu(); 2385 2386 free_cpumask_var(cpu_mask); 2387 2388 return 0; 2389 } 2390 2391 /* 2392 * Move tasks from one to the other group. If @from is NULL, then all tasks 2393 * in the systems are moved unconditionally (used for teardown). 2394 * 2395 * If @mask is not NULL the cpus on which moved tasks are running are set 2396 * in that mask so the update smp function call is restricted to affected 2397 * cpus. 2398 */ 2399 static void rdt_move_group_tasks(struct rdtgroup *from, struct rdtgroup *to, 2400 struct cpumask *mask) 2401 { 2402 struct task_struct *p, *t; 2403 2404 read_lock(&tasklist_lock); 2405 for_each_process_thread(p, t) { 2406 if (!from || is_closid_match(t, from) || 2407 is_rmid_match(t, from)) { 2408 WRITE_ONCE(t->closid, to->closid); 2409 WRITE_ONCE(t->rmid, to->mon.rmid); 2410 2411 /* 2412 * If the task is on a CPU, set the CPU in the mask. 2413 * The detection is inaccurate as tasks might move or 2414 * schedule before the smp function call takes place. 2415 * In such a case the function call is pointless, but 2416 * there is no other side effect. 2417 */ 2418 if (IS_ENABLED(CONFIG_SMP) && mask && task_curr(t)) 2419 cpumask_set_cpu(task_cpu(t), mask); 2420 } 2421 } 2422 read_unlock(&tasklist_lock); 2423 } 2424 2425 static void free_all_child_rdtgrp(struct rdtgroup *rdtgrp) 2426 { 2427 struct rdtgroup *sentry, *stmp; 2428 struct list_head *head; 2429 2430 head = &rdtgrp->mon.crdtgrp_list; 2431 list_for_each_entry_safe(sentry, stmp, head, mon.crdtgrp_list) { 2432 free_rmid(sentry->mon.rmid); 2433 list_del(&sentry->mon.crdtgrp_list); 2434 2435 if (atomic_read(&sentry->waitcount) != 0) 2436 sentry->flags = RDT_DELETED; 2437 else 2438 rdtgroup_remove(sentry); 2439 } 2440 } 2441 2442 /* 2443 * Forcibly remove all of subdirectories under root. 2444 */ 2445 static void rmdir_all_sub(void) 2446 { 2447 struct rdtgroup *rdtgrp, *tmp; 2448 2449 /* Move all tasks to the default resource group */ 2450 rdt_move_group_tasks(NULL, &rdtgroup_default, NULL); 2451 2452 list_for_each_entry_safe(rdtgrp, tmp, &rdt_all_groups, rdtgroup_list) { 2453 /* Free any child rmids */ 2454 free_all_child_rdtgrp(rdtgrp); 2455 2456 /* Remove each rdtgroup other than root */ 2457 if (rdtgrp == &rdtgroup_default) 2458 continue; 2459 2460 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2461 rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2462 rdtgroup_pseudo_lock_remove(rdtgrp); 2463 2464 /* 2465 * Give any CPUs back to the default group. We cannot copy 2466 * cpu_online_mask because a CPU might have executed the 2467 * offline callback already, but is still marked online. 2468 */ 2469 cpumask_or(&rdtgroup_default.cpu_mask, 2470 &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 2471 2472 free_rmid(rdtgrp->mon.rmid); 2473 2474 kernfs_remove(rdtgrp->kn); 2475 list_del(&rdtgrp->rdtgroup_list); 2476 2477 if (atomic_read(&rdtgrp->waitcount) != 0) 2478 rdtgrp->flags = RDT_DELETED; 2479 else 2480 rdtgroup_remove(rdtgrp); 2481 } 2482 /* Notify online CPUs to update per cpu storage and PQR_ASSOC MSR */ 2483 update_closid_rmid(cpu_online_mask, &rdtgroup_default); 2484 2485 kernfs_remove(kn_info); 2486 kernfs_remove(kn_mongrp); 2487 kernfs_remove(kn_mondata); 2488 } 2489 2490 static void rdt_kill_sb(struct super_block *sb) 2491 { 2492 struct rdt_resource *r; 2493 2494 cpus_read_lock(); 2495 mutex_lock(&rdtgroup_mutex); 2496 2497 set_mba_sc(false); 2498 2499 /*Put everything back to default values. */ 2500 for_each_alloc_capable_rdt_resource(r) 2501 reset_all_ctrls(r); 2502 cdp_disable_all(); 2503 rmdir_all_sub(); 2504 rdt_pseudo_lock_release(); 2505 rdtgroup_default.mode = RDT_MODE_SHAREABLE; 2506 schemata_list_destroy(); 2507 static_branch_disable_cpuslocked(&rdt_alloc_enable_key); 2508 static_branch_disable_cpuslocked(&rdt_mon_enable_key); 2509 static_branch_disable_cpuslocked(&rdt_enable_key); 2510 kernfs_kill_sb(sb); 2511 mutex_unlock(&rdtgroup_mutex); 2512 cpus_read_unlock(); 2513 } 2514 2515 static struct file_system_type rdt_fs_type = { 2516 .name = "resctrl", 2517 .init_fs_context = rdt_init_fs_context, 2518 .parameters = rdt_fs_parameters, 2519 .kill_sb = rdt_kill_sb, 2520 }; 2521 2522 static int mon_addfile(struct kernfs_node *parent_kn, const char *name, 2523 void *priv) 2524 { 2525 struct kernfs_node *kn; 2526 int ret = 0; 2527 2528 kn = __kernfs_create_file(parent_kn, name, 0444, 2529 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 0, 2530 &kf_mondata_ops, priv, NULL, NULL); 2531 if (IS_ERR(kn)) 2532 return PTR_ERR(kn); 2533 2534 ret = rdtgroup_kn_set_ugid(kn); 2535 if (ret) { 2536 kernfs_remove(kn); 2537 return ret; 2538 } 2539 2540 return ret; 2541 } 2542 2543 /* 2544 * Remove all subdirectories of mon_data of ctrl_mon groups 2545 * and monitor groups with given domain id. 2546 */ 2547 static void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 2548 unsigned int dom_id) 2549 { 2550 struct rdtgroup *prgrp, *crgrp; 2551 char name[32]; 2552 2553 list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 2554 sprintf(name, "mon_%s_%02d", r->name, dom_id); 2555 kernfs_remove_by_name(prgrp->mon.mon_data_kn, name); 2556 2557 list_for_each_entry(crgrp, &prgrp->mon.crdtgrp_list, mon.crdtgrp_list) 2558 kernfs_remove_by_name(crgrp->mon.mon_data_kn, name); 2559 } 2560 } 2561 2562 static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, 2563 struct rdt_domain *d, 2564 struct rdt_resource *r, struct rdtgroup *prgrp) 2565 { 2566 union mon_data_bits priv; 2567 struct kernfs_node *kn; 2568 struct mon_evt *mevt; 2569 struct rmid_read rr; 2570 char name[32]; 2571 int ret; 2572 2573 sprintf(name, "mon_%s_%02d", r->name, d->id); 2574 /* create the directory */ 2575 kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 2576 if (IS_ERR(kn)) 2577 return PTR_ERR(kn); 2578 2579 ret = rdtgroup_kn_set_ugid(kn); 2580 if (ret) 2581 goto out_destroy; 2582 2583 if (WARN_ON(list_empty(&r->evt_list))) { 2584 ret = -EPERM; 2585 goto out_destroy; 2586 } 2587 2588 priv.u.rid = r->rid; 2589 priv.u.domid = d->id; 2590 list_for_each_entry(mevt, &r->evt_list, list) { 2591 priv.u.evtid = mevt->evtid; 2592 ret = mon_addfile(kn, mevt->name, priv.priv); 2593 if (ret) 2594 goto out_destroy; 2595 2596 if (is_mbm_event(mevt->evtid)) 2597 mon_event_read(&rr, r, d, prgrp, mevt->evtid, true); 2598 } 2599 kernfs_activate(kn); 2600 return 0; 2601 2602 out_destroy: 2603 kernfs_remove(kn); 2604 return ret; 2605 } 2606 2607 /* 2608 * Add all subdirectories of mon_data for "ctrl_mon" groups 2609 * and "monitor" groups with given domain id. 2610 */ 2611 static void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 2612 struct rdt_domain *d) 2613 { 2614 struct kernfs_node *parent_kn; 2615 struct rdtgroup *prgrp, *crgrp; 2616 struct list_head *head; 2617 2618 list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 2619 parent_kn = prgrp->mon.mon_data_kn; 2620 mkdir_mondata_subdir(parent_kn, d, r, prgrp); 2621 2622 head = &prgrp->mon.crdtgrp_list; 2623 list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 2624 parent_kn = crgrp->mon.mon_data_kn; 2625 mkdir_mondata_subdir(parent_kn, d, r, crgrp); 2626 } 2627 } 2628 } 2629 2630 static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, 2631 struct rdt_resource *r, 2632 struct rdtgroup *prgrp) 2633 { 2634 struct rdt_domain *dom; 2635 int ret; 2636 2637 list_for_each_entry(dom, &r->domains, list) { 2638 ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp); 2639 if (ret) 2640 return ret; 2641 } 2642 2643 return 0; 2644 } 2645 2646 /* 2647 * This creates a directory mon_data which contains the monitored data. 2648 * 2649 * mon_data has one directory for each domain which are named 2650 * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data 2651 * with L3 domain looks as below: 2652 * ./mon_data: 2653 * mon_L3_00 2654 * mon_L3_01 2655 * mon_L3_02 2656 * ... 2657 * 2658 * Each domain directory has one file per event: 2659 * ./mon_L3_00/: 2660 * llc_occupancy 2661 * 2662 */ 2663 static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2664 struct rdtgroup *prgrp, 2665 struct kernfs_node **dest_kn) 2666 { 2667 struct rdt_resource *r; 2668 struct kernfs_node *kn; 2669 int ret; 2670 2671 /* 2672 * Create the mon_data directory first. 2673 */ 2674 ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn); 2675 if (ret) 2676 return ret; 2677 2678 if (dest_kn) 2679 *dest_kn = kn; 2680 2681 /* 2682 * Create the subdirectories for each domain. Note that all events 2683 * in a domain like L3 are grouped into a resource whose domain is L3 2684 */ 2685 for_each_mon_capable_rdt_resource(r) { 2686 ret = mkdir_mondata_subdir_alldom(kn, r, prgrp); 2687 if (ret) 2688 goto out_destroy; 2689 } 2690 2691 return 0; 2692 2693 out_destroy: 2694 kernfs_remove(kn); 2695 return ret; 2696 } 2697 2698 /** 2699 * cbm_ensure_valid - Enforce validity on provided CBM 2700 * @_val: Candidate CBM 2701 * @r: RDT resource to which the CBM belongs 2702 * 2703 * The provided CBM represents all cache portions available for use. This 2704 * may be represented by a bitmap that does not consist of contiguous ones 2705 * and thus be an invalid CBM. 2706 * Here the provided CBM is forced to be a valid CBM by only considering 2707 * the first set of contiguous bits as valid and clearing all bits. 2708 * The intention here is to provide a valid default CBM with which a new 2709 * resource group is initialized. The user can follow this with a 2710 * modification to the CBM if the default does not satisfy the 2711 * requirements. 2712 */ 2713 static u32 cbm_ensure_valid(u32 _val, struct rdt_resource *r) 2714 { 2715 unsigned int cbm_len = r->cache.cbm_len; 2716 unsigned long first_bit, zero_bit; 2717 unsigned long val = _val; 2718 2719 if (!val) 2720 return 0; 2721 2722 first_bit = find_first_bit(&val, cbm_len); 2723 zero_bit = find_next_zero_bit(&val, cbm_len, first_bit); 2724 2725 /* Clear any remaining bits to ensure contiguous region */ 2726 bitmap_clear(&val, zero_bit, cbm_len - zero_bit); 2727 return (u32)val; 2728 } 2729 2730 /* 2731 * Initialize cache resources per RDT domain 2732 * 2733 * Set the RDT domain up to start off with all usable allocations. That is, 2734 * all shareable and unused bits. All-zero CBM is invalid. 2735 */ 2736 static int __init_one_rdt_domain(struct rdt_domain *d, struct resctrl_schema *s, 2737 u32 closid) 2738 { 2739 enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 2740 enum resctrl_conf_type t = s->conf_type; 2741 struct resctrl_staged_config *cfg; 2742 struct rdt_resource *r = s->res; 2743 u32 used_b = 0, unused_b = 0; 2744 unsigned long tmp_cbm; 2745 enum rdtgrp_mode mode; 2746 u32 peer_ctl, ctrl_val; 2747 int i; 2748 2749 cfg = &d->staged_config[t]; 2750 cfg->have_new_ctrl = false; 2751 cfg->new_ctrl = r->cache.shareable_bits; 2752 used_b = r->cache.shareable_bits; 2753 for (i = 0; i < closids_supported(); i++) { 2754 if (closid_allocated(i) && i != closid) { 2755 mode = rdtgroup_mode_by_closid(i); 2756 if (mode == RDT_MODE_PSEUDO_LOCKSETUP) 2757 /* 2758 * ctrl values for locksetup aren't relevant 2759 * until the schemata is written, and the mode 2760 * becomes RDT_MODE_PSEUDO_LOCKED. 2761 */ 2762 continue; 2763 /* 2764 * If CDP is active include peer domain's 2765 * usage to ensure there is no overlap 2766 * with an exclusive group. 2767 */ 2768 if (resctrl_arch_get_cdp_enabled(r->rid)) 2769 peer_ctl = resctrl_arch_get_config(r, d, i, 2770 peer_type); 2771 else 2772 peer_ctl = 0; 2773 ctrl_val = resctrl_arch_get_config(r, d, i, 2774 s->conf_type); 2775 used_b |= ctrl_val | peer_ctl; 2776 if (mode == RDT_MODE_SHAREABLE) 2777 cfg->new_ctrl |= ctrl_val | peer_ctl; 2778 } 2779 } 2780 if (d->plr && d->plr->cbm > 0) 2781 used_b |= d->plr->cbm; 2782 unused_b = used_b ^ (BIT_MASK(r->cache.cbm_len) - 1); 2783 unused_b &= BIT_MASK(r->cache.cbm_len) - 1; 2784 cfg->new_ctrl |= unused_b; 2785 /* 2786 * Force the initial CBM to be valid, user can 2787 * modify the CBM based on system availability. 2788 */ 2789 cfg->new_ctrl = cbm_ensure_valid(cfg->new_ctrl, r); 2790 /* 2791 * Assign the u32 CBM to an unsigned long to ensure that 2792 * bitmap_weight() does not access out-of-bound memory. 2793 */ 2794 tmp_cbm = cfg->new_ctrl; 2795 if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) { 2796 rdt_last_cmd_printf("No space on %s:%d\n", s->name, d->id); 2797 return -ENOSPC; 2798 } 2799 cfg->have_new_ctrl = true; 2800 2801 return 0; 2802 } 2803 2804 /* 2805 * Initialize cache resources with default values. 2806 * 2807 * A new RDT group is being created on an allocation capable (CAT) 2808 * supporting system. Set this group up to start off with all usable 2809 * allocations. 2810 * 2811 * If there are no more shareable bits available on any domain then 2812 * the entire allocation will fail. 2813 */ 2814 static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) 2815 { 2816 struct rdt_domain *d; 2817 int ret; 2818 2819 list_for_each_entry(d, &s->res->domains, list) { 2820 ret = __init_one_rdt_domain(d, s, closid); 2821 if (ret < 0) 2822 return ret; 2823 } 2824 2825 return 0; 2826 } 2827 2828 /* Initialize MBA resource with default values. */ 2829 static void rdtgroup_init_mba(struct rdt_resource *r, u32 closid) 2830 { 2831 struct resctrl_staged_config *cfg; 2832 struct rdt_domain *d; 2833 2834 list_for_each_entry(d, &r->domains, list) { 2835 if (is_mba_sc(r)) { 2836 d->mbps_val[closid] = MBA_MAX_MBPS; 2837 continue; 2838 } 2839 2840 cfg = &d->staged_config[CDP_NONE]; 2841 cfg->new_ctrl = r->default_ctrl; 2842 cfg->have_new_ctrl = true; 2843 } 2844 } 2845 2846 /* Initialize the RDT group's allocations. */ 2847 static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp) 2848 { 2849 struct resctrl_schema *s; 2850 struct rdt_resource *r; 2851 int ret; 2852 2853 list_for_each_entry(s, &resctrl_schema_all, list) { 2854 r = s->res; 2855 if (r->rid == RDT_RESOURCE_MBA) { 2856 rdtgroup_init_mba(r, rdtgrp->closid); 2857 if (is_mba_sc(r)) 2858 continue; 2859 } else { 2860 ret = rdtgroup_init_cat(s, rdtgrp->closid); 2861 if (ret < 0) 2862 return ret; 2863 } 2864 2865 ret = resctrl_arch_update_domains(r, rdtgrp->closid); 2866 if (ret < 0) { 2867 rdt_last_cmd_puts("Failed to initialize allocations\n"); 2868 return ret; 2869 } 2870 2871 } 2872 2873 rdtgrp->mode = RDT_MODE_SHAREABLE; 2874 2875 return 0; 2876 } 2877 2878 static int mkdir_rdt_prepare(struct kernfs_node *parent_kn, 2879 const char *name, umode_t mode, 2880 enum rdt_group_type rtype, struct rdtgroup **r) 2881 { 2882 struct rdtgroup *prdtgrp, *rdtgrp; 2883 struct kernfs_node *kn; 2884 uint files = 0; 2885 int ret; 2886 2887 prdtgrp = rdtgroup_kn_lock_live(parent_kn); 2888 if (!prdtgrp) { 2889 ret = -ENODEV; 2890 goto out_unlock; 2891 } 2892 2893 if (rtype == RDTMON_GROUP && 2894 (prdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2895 prdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)) { 2896 ret = -EINVAL; 2897 rdt_last_cmd_puts("Pseudo-locking in progress\n"); 2898 goto out_unlock; 2899 } 2900 2901 /* allocate the rdtgroup. */ 2902 rdtgrp = kzalloc(sizeof(*rdtgrp), GFP_KERNEL); 2903 if (!rdtgrp) { 2904 ret = -ENOSPC; 2905 rdt_last_cmd_puts("Kernel out of memory\n"); 2906 goto out_unlock; 2907 } 2908 *r = rdtgrp; 2909 rdtgrp->mon.parent = prdtgrp; 2910 rdtgrp->type = rtype; 2911 INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list); 2912 2913 /* kernfs creates the directory for rdtgrp */ 2914 kn = kernfs_create_dir(parent_kn, name, mode, rdtgrp); 2915 if (IS_ERR(kn)) { 2916 ret = PTR_ERR(kn); 2917 rdt_last_cmd_puts("kernfs create error\n"); 2918 goto out_free_rgrp; 2919 } 2920 rdtgrp->kn = kn; 2921 2922 /* 2923 * kernfs_remove() will drop the reference count on "kn" which 2924 * will free it. But we still need it to stick around for the 2925 * rdtgroup_kn_unlock(kn) call. Take one extra reference here, 2926 * which will be dropped by kernfs_put() in rdtgroup_remove(). 2927 */ 2928 kernfs_get(kn); 2929 2930 ret = rdtgroup_kn_set_ugid(kn); 2931 if (ret) { 2932 rdt_last_cmd_puts("kernfs perm error\n"); 2933 goto out_destroy; 2934 } 2935 2936 files = RFTYPE_BASE | BIT(RF_CTRLSHIFT + rtype); 2937 ret = rdtgroup_add_files(kn, files); 2938 if (ret) { 2939 rdt_last_cmd_puts("kernfs fill error\n"); 2940 goto out_destroy; 2941 } 2942 2943 if (rdt_mon_capable) { 2944 ret = alloc_rmid(); 2945 if (ret < 0) { 2946 rdt_last_cmd_puts("Out of RMIDs\n"); 2947 goto out_destroy; 2948 } 2949 rdtgrp->mon.rmid = ret; 2950 2951 ret = mkdir_mondata_all(kn, rdtgrp, &rdtgrp->mon.mon_data_kn); 2952 if (ret) { 2953 rdt_last_cmd_puts("kernfs subdir error\n"); 2954 goto out_idfree; 2955 } 2956 } 2957 kernfs_activate(kn); 2958 2959 /* 2960 * The caller unlocks the parent_kn upon success. 2961 */ 2962 return 0; 2963 2964 out_idfree: 2965 free_rmid(rdtgrp->mon.rmid); 2966 out_destroy: 2967 kernfs_put(rdtgrp->kn); 2968 kernfs_remove(rdtgrp->kn); 2969 out_free_rgrp: 2970 kfree(rdtgrp); 2971 out_unlock: 2972 rdtgroup_kn_unlock(parent_kn); 2973 return ret; 2974 } 2975 2976 static void mkdir_rdt_prepare_clean(struct rdtgroup *rgrp) 2977 { 2978 kernfs_remove(rgrp->kn); 2979 free_rmid(rgrp->mon.rmid); 2980 rdtgroup_remove(rgrp); 2981 } 2982 2983 /* 2984 * Create a monitor group under "mon_groups" directory of a control 2985 * and monitor group(ctrl_mon). This is a resource group 2986 * to monitor a subset of tasks and cpus in its parent ctrl_mon group. 2987 */ 2988 static int rdtgroup_mkdir_mon(struct kernfs_node *parent_kn, 2989 const char *name, umode_t mode) 2990 { 2991 struct rdtgroup *rdtgrp, *prgrp; 2992 int ret; 2993 2994 ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTMON_GROUP, &rdtgrp); 2995 if (ret) 2996 return ret; 2997 2998 prgrp = rdtgrp->mon.parent; 2999 rdtgrp->closid = prgrp->closid; 3000 3001 /* 3002 * Add the rdtgrp to the list of rdtgrps the parent 3003 * ctrl_mon group has to track. 3004 */ 3005 list_add_tail(&rdtgrp->mon.crdtgrp_list, &prgrp->mon.crdtgrp_list); 3006 3007 rdtgroup_kn_unlock(parent_kn); 3008 return ret; 3009 } 3010 3011 /* 3012 * These are rdtgroups created under the root directory. Can be used 3013 * to allocate and monitor resources. 3014 */ 3015 static int rdtgroup_mkdir_ctrl_mon(struct kernfs_node *parent_kn, 3016 const char *name, umode_t mode) 3017 { 3018 struct rdtgroup *rdtgrp; 3019 struct kernfs_node *kn; 3020 u32 closid; 3021 int ret; 3022 3023 ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTCTRL_GROUP, &rdtgrp); 3024 if (ret) 3025 return ret; 3026 3027 kn = rdtgrp->kn; 3028 ret = closid_alloc(); 3029 if (ret < 0) { 3030 rdt_last_cmd_puts("Out of CLOSIDs\n"); 3031 goto out_common_fail; 3032 } 3033 closid = ret; 3034 ret = 0; 3035 3036 rdtgrp->closid = closid; 3037 ret = rdtgroup_init_alloc(rdtgrp); 3038 if (ret < 0) 3039 goto out_id_free; 3040 3041 list_add(&rdtgrp->rdtgroup_list, &rdt_all_groups); 3042 3043 if (rdt_mon_capable) { 3044 /* 3045 * Create an empty mon_groups directory to hold the subset 3046 * of tasks and cpus to monitor. 3047 */ 3048 ret = mongroup_create_dir(kn, rdtgrp, "mon_groups", NULL); 3049 if (ret) { 3050 rdt_last_cmd_puts("kernfs subdir error\n"); 3051 goto out_del_list; 3052 } 3053 } 3054 3055 goto out_unlock; 3056 3057 out_del_list: 3058 list_del(&rdtgrp->rdtgroup_list); 3059 out_id_free: 3060 closid_free(closid); 3061 out_common_fail: 3062 mkdir_rdt_prepare_clean(rdtgrp); 3063 out_unlock: 3064 rdtgroup_kn_unlock(parent_kn); 3065 return ret; 3066 } 3067 3068 /* 3069 * We allow creating mon groups only with in a directory called "mon_groups" 3070 * which is present in every ctrl_mon group. Check if this is a valid 3071 * "mon_groups" directory. 3072 * 3073 * 1. The directory should be named "mon_groups". 3074 * 2. The mon group itself should "not" be named "mon_groups". 3075 * This makes sure "mon_groups" directory always has a ctrl_mon group 3076 * as parent. 3077 */ 3078 static bool is_mon_groups(struct kernfs_node *kn, const char *name) 3079 { 3080 return (!strcmp(kn->name, "mon_groups") && 3081 strcmp(name, "mon_groups")); 3082 } 3083 3084 static int rdtgroup_mkdir(struct kernfs_node *parent_kn, const char *name, 3085 umode_t mode) 3086 { 3087 /* Do not accept '\n' to avoid unparsable situation. */ 3088 if (strchr(name, '\n')) 3089 return -EINVAL; 3090 3091 /* 3092 * If the parent directory is the root directory and RDT 3093 * allocation is supported, add a control and monitoring 3094 * subdirectory 3095 */ 3096 if (rdt_alloc_capable && parent_kn == rdtgroup_default.kn) 3097 return rdtgroup_mkdir_ctrl_mon(parent_kn, name, mode); 3098 3099 /* 3100 * If RDT monitoring is supported and the parent directory is a valid 3101 * "mon_groups" directory, add a monitoring subdirectory. 3102 */ 3103 if (rdt_mon_capable && is_mon_groups(parent_kn, name)) 3104 return rdtgroup_mkdir_mon(parent_kn, name, mode); 3105 3106 return -EPERM; 3107 } 3108 3109 static int rdtgroup_rmdir_mon(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3110 { 3111 struct rdtgroup *prdtgrp = rdtgrp->mon.parent; 3112 int cpu; 3113 3114 /* Give any tasks back to the parent group */ 3115 rdt_move_group_tasks(rdtgrp, prdtgrp, tmpmask); 3116 3117 /* Update per cpu rmid of the moved CPUs first */ 3118 for_each_cpu(cpu, &rdtgrp->cpu_mask) 3119 per_cpu(pqr_state.default_rmid, cpu) = prdtgrp->mon.rmid; 3120 /* 3121 * Update the MSR on moved CPUs and CPUs which have moved 3122 * task running on them. 3123 */ 3124 cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3125 update_closid_rmid(tmpmask, NULL); 3126 3127 rdtgrp->flags = RDT_DELETED; 3128 free_rmid(rdtgrp->mon.rmid); 3129 3130 /* 3131 * Remove the rdtgrp from the parent ctrl_mon group's list 3132 */ 3133 WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list)); 3134 list_del(&rdtgrp->mon.crdtgrp_list); 3135 3136 kernfs_remove(rdtgrp->kn); 3137 3138 return 0; 3139 } 3140 3141 static int rdtgroup_ctrl_remove(struct rdtgroup *rdtgrp) 3142 { 3143 rdtgrp->flags = RDT_DELETED; 3144 list_del(&rdtgrp->rdtgroup_list); 3145 3146 kernfs_remove(rdtgrp->kn); 3147 return 0; 3148 } 3149 3150 static int rdtgroup_rmdir_ctrl(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3151 { 3152 int cpu; 3153 3154 /* Give any tasks back to the default group */ 3155 rdt_move_group_tasks(rdtgrp, &rdtgroup_default, tmpmask); 3156 3157 /* Give any CPUs back to the default group */ 3158 cpumask_or(&rdtgroup_default.cpu_mask, 3159 &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 3160 3161 /* Update per cpu closid and rmid of the moved CPUs first */ 3162 for_each_cpu(cpu, &rdtgrp->cpu_mask) { 3163 per_cpu(pqr_state.default_closid, cpu) = rdtgroup_default.closid; 3164 per_cpu(pqr_state.default_rmid, cpu) = rdtgroup_default.mon.rmid; 3165 } 3166 3167 /* 3168 * Update the MSR on moved CPUs and CPUs which have moved 3169 * task running on them. 3170 */ 3171 cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3172 update_closid_rmid(tmpmask, NULL); 3173 3174 closid_free(rdtgrp->closid); 3175 free_rmid(rdtgrp->mon.rmid); 3176 3177 rdtgroup_ctrl_remove(rdtgrp); 3178 3179 /* 3180 * Free all the child monitor group rmids. 3181 */ 3182 free_all_child_rdtgrp(rdtgrp); 3183 3184 return 0; 3185 } 3186 3187 static int rdtgroup_rmdir(struct kernfs_node *kn) 3188 { 3189 struct kernfs_node *parent_kn = kn->parent; 3190 struct rdtgroup *rdtgrp; 3191 cpumask_var_t tmpmask; 3192 int ret = 0; 3193 3194 if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 3195 return -ENOMEM; 3196 3197 rdtgrp = rdtgroup_kn_lock_live(kn); 3198 if (!rdtgrp) { 3199 ret = -EPERM; 3200 goto out; 3201 } 3202 3203 /* 3204 * If the rdtgroup is a ctrl_mon group and parent directory 3205 * is the root directory, remove the ctrl_mon group. 3206 * 3207 * If the rdtgroup is a mon group and parent directory 3208 * is a valid "mon_groups" directory, remove the mon group. 3209 */ 3210 if (rdtgrp->type == RDTCTRL_GROUP && parent_kn == rdtgroup_default.kn && 3211 rdtgrp != &rdtgroup_default) { 3212 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 3213 rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 3214 ret = rdtgroup_ctrl_remove(rdtgrp); 3215 } else { 3216 ret = rdtgroup_rmdir_ctrl(rdtgrp, tmpmask); 3217 } 3218 } else if (rdtgrp->type == RDTMON_GROUP && 3219 is_mon_groups(parent_kn, kn->name)) { 3220 ret = rdtgroup_rmdir_mon(rdtgrp, tmpmask); 3221 } else { 3222 ret = -EPERM; 3223 } 3224 3225 out: 3226 rdtgroup_kn_unlock(kn); 3227 free_cpumask_var(tmpmask); 3228 return ret; 3229 } 3230 3231 static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf) 3232 { 3233 if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3)) 3234 seq_puts(seq, ",cdp"); 3235 3236 if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) 3237 seq_puts(seq, ",cdpl2"); 3238 3239 if (is_mba_sc(&rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl)) 3240 seq_puts(seq, ",mba_MBps"); 3241 3242 return 0; 3243 } 3244 3245 static struct kernfs_syscall_ops rdtgroup_kf_syscall_ops = { 3246 .mkdir = rdtgroup_mkdir, 3247 .rmdir = rdtgroup_rmdir, 3248 .show_options = rdtgroup_show_options, 3249 }; 3250 3251 static int __init rdtgroup_setup_root(void) 3252 { 3253 int ret; 3254 3255 rdt_root = kernfs_create_root(&rdtgroup_kf_syscall_ops, 3256 KERNFS_ROOT_CREATE_DEACTIVATED | 3257 KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK, 3258 &rdtgroup_default); 3259 if (IS_ERR(rdt_root)) 3260 return PTR_ERR(rdt_root); 3261 3262 mutex_lock(&rdtgroup_mutex); 3263 3264 rdtgroup_default.closid = 0; 3265 rdtgroup_default.mon.rmid = 0; 3266 rdtgroup_default.type = RDTCTRL_GROUP; 3267 INIT_LIST_HEAD(&rdtgroup_default.mon.crdtgrp_list); 3268 3269 list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups); 3270 3271 ret = rdtgroup_add_files(kernfs_root_to_node(rdt_root), RF_CTRL_BASE); 3272 if (ret) { 3273 kernfs_destroy_root(rdt_root); 3274 goto out; 3275 } 3276 3277 rdtgroup_default.kn = kernfs_root_to_node(rdt_root); 3278 kernfs_activate(rdtgroup_default.kn); 3279 3280 out: 3281 mutex_unlock(&rdtgroup_mutex); 3282 3283 return ret; 3284 } 3285 3286 static void domain_destroy_mon_state(struct rdt_domain *d) 3287 { 3288 bitmap_free(d->rmid_busy_llc); 3289 kfree(d->mbm_total); 3290 kfree(d->mbm_local); 3291 } 3292 3293 void resctrl_offline_domain(struct rdt_resource *r, struct rdt_domain *d) 3294 { 3295 lockdep_assert_held(&rdtgroup_mutex); 3296 3297 if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) 3298 mba_sc_domain_destroy(r, d); 3299 3300 if (!r->mon_capable) 3301 return; 3302 3303 /* 3304 * If resctrl is mounted, remove all the 3305 * per domain monitor data directories. 3306 */ 3307 if (static_branch_unlikely(&rdt_mon_enable_key)) 3308 rmdir_mondata_subdir_allrdtgrp(r, d->id); 3309 3310 if (is_mbm_enabled()) 3311 cancel_delayed_work(&d->mbm_over); 3312 if (is_llc_occupancy_enabled() && has_busy_rmid(r, d)) { 3313 /* 3314 * When a package is going down, forcefully 3315 * decrement rmid->ebusy. There is no way to know 3316 * that the L3 was flushed and hence may lead to 3317 * incorrect counts in rare scenarios, but leaving 3318 * the RMID as busy creates RMID leaks if the 3319 * package never comes back. 3320 */ 3321 __check_limbo(d, true); 3322 cancel_delayed_work(&d->cqm_limbo); 3323 } 3324 3325 domain_destroy_mon_state(d); 3326 } 3327 3328 static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_domain *d) 3329 { 3330 size_t tsize; 3331 3332 if (is_llc_occupancy_enabled()) { 3333 d->rmid_busy_llc = bitmap_zalloc(r->num_rmid, GFP_KERNEL); 3334 if (!d->rmid_busy_llc) 3335 return -ENOMEM; 3336 } 3337 if (is_mbm_total_enabled()) { 3338 tsize = sizeof(*d->mbm_total); 3339 d->mbm_total = kcalloc(r->num_rmid, tsize, GFP_KERNEL); 3340 if (!d->mbm_total) { 3341 bitmap_free(d->rmid_busy_llc); 3342 return -ENOMEM; 3343 } 3344 } 3345 if (is_mbm_local_enabled()) { 3346 tsize = sizeof(*d->mbm_local); 3347 d->mbm_local = kcalloc(r->num_rmid, tsize, GFP_KERNEL); 3348 if (!d->mbm_local) { 3349 bitmap_free(d->rmid_busy_llc); 3350 kfree(d->mbm_total); 3351 return -ENOMEM; 3352 } 3353 } 3354 3355 return 0; 3356 } 3357 3358 int resctrl_online_domain(struct rdt_resource *r, struct rdt_domain *d) 3359 { 3360 int err; 3361 3362 lockdep_assert_held(&rdtgroup_mutex); 3363 3364 if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) 3365 /* RDT_RESOURCE_MBA is never mon_capable */ 3366 return mba_sc_domain_allocate(r, d); 3367 3368 if (!r->mon_capable) 3369 return 0; 3370 3371 err = domain_setup_mon_state(r, d); 3372 if (err) 3373 return err; 3374 3375 if (is_mbm_enabled()) { 3376 INIT_DELAYED_WORK(&d->mbm_over, mbm_handle_overflow); 3377 mbm_setup_overflow_handler(d, MBM_OVERFLOW_INTERVAL); 3378 } 3379 3380 if (is_llc_occupancy_enabled()) 3381 INIT_DELAYED_WORK(&d->cqm_limbo, cqm_handle_limbo); 3382 3383 /* If resctrl is mounted, add per domain monitor data directories. */ 3384 if (static_branch_unlikely(&rdt_mon_enable_key)) 3385 mkdir_mondata_subdir_allrdtgrp(r, d); 3386 3387 return 0; 3388 } 3389 3390 /* 3391 * rdtgroup_init - rdtgroup initialization 3392 * 3393 * Setup resctrl file system including set up root, create mount point, 3394 * register rdtgroup filesystem, and initialize files under root directory. 3395 * 3396 * Return: 0 on success or -errno 3397 */ 3398 int __init rdtgroup_init(void) 3399 { 3400 int ret = 0; 3401 3402 seq_buf_init(&last_cmd_status, last_cmd_status_buf, 3403 sizeof(last_cmd_status_buf)); 3404 3405 ret = rdtgroup_setup_root(); 3406 if (ret) 3407 return ret; 3408 3409 ret = sysfs_create_mount_point(fs_kobj, "resctrl"); 3410 if (ret) 3411 goto cleanup_root; 3412 3413 ret = register_filesystem(&rdt_fs_type); 3414 if (ret) 3415 goto cleanup_mountpoint; 3416 3417 /* 3418 * Adding the resctrl debugfs directory here may not be ideal since 3419 * it would let the resctrl debugfs directory appear on the debugfs 3420 * filesystem before the resctrl filesystem is mounted. 3421 * It may also be ok since that would enable debugging of RDT before 3422 * resctrl is mounted. 3423 * The reason why the debugfs directory is created here and not in 3424 * rdt_get_tree() is because rdt_get_tree() takes rdtgroup_mutex and 3425 * during the debugfs directory creation also &sb->s_type->i_mutex_key 3426 * (the lockdep class of inode->i_rwsem). Other filesystem 3427 * interactions (eg. SyS_getdents) have the lock ordering: 3428 * &sb->s_type->i_mutex_key --> &mm->mmap_lock 3429 * During mmap(), called with &mm->mmap_lock, the rdtgroup_mutex 3430 * is taken, thus creating dependency: 3431 * &mm->mmap_lock --> rdtgroup_mutex for the latter that can cause 3432 * issues considering the other two lock dependencies. 3433 * By creating the debugfs directory here we avoid a dependency 3434 * that may cause deadlock (even though file operations cannot 3435 * occur until the filesystem is mounted, but I do not know how to 3436 * tell lockdep that). 3437 */ 3438 debugfs_resctrl = debugfs_create_dir("resctrl", NULL); 3439 3440 return 0; 3441 3442 cleanup_mountpoint: 3443 sysfs_remove_mount_point(fs_kobj, "resctrl"); 3444 cleanup_root: 3445 kernfs_destroy_root(rdt_root); 3446 3447 return ret; 3448 } 3449 3450 void __exit rdtgroup_exit(void) 3451 { 3452 debugfs_remove_recursive(debugfs_resctrl); 3453 unregister_filesystem(&rdt_fs_type); 3454 sysfs_remove_mount_point(fs_kobj, "resctrl"); 3455 kernfs_destroy_root(rdt_root); 3456 } 3457