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 struct rdtgroup *rdtgrp; 1360 struct rdt_resource *r; 1361 struct rdt_domain *d; 1362 unsigned int size; 1363 int ret = 0; 1364 bool sep; 1365 u32 ctrl; 1366 1367 rdtgrp = rdtgroup_kn_lock_live(of->kn); 1368 if (!rdtgrp) { 1369 rdtgroup_kn_unlock(of->kn); 1370 return -ENOENT; 1371 } 1372 1373 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 1374 if (!rdtgrp->plr->d) { 1375 rdt_last_cmd_clear(); 1376 rdt_last_cmd_puts("Cache domain offline\n"); 1377 ret = -ENODEV; 1378 } else { 1379 seq_printf(s, "%*s:", max_name_width, 1380 rdtgrp->plr->s->name); 1381 size = rdtgroup_cbm_to_size(rdtgrp->plr->s->res, 1382 rdtgrp->plr->d, 1383 rdtgrp->plr->cbm); 1384 seq_printf(s, "%d=%u\n", rdtgrp->plr->d->id, size); 1385 } 1386 goto out; 1387 } 1388 1389 list_for_each_entry(schema, &resctrl_schema_all, list) { 1390 r = schema->res; 1391 sep = false; 1392 seq_printf(s, "%*s:", max_name_width, schema->name); 1393 list_for_each_entry(d, &r->domains, list) { 1394 if (sep) 1395 seq_putc(s, ';'); 1396 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1397 size = 0; 1398 } else { 1399 ctrl = resctrl_arch_get_config(r, d, 1400 rdtgrp->closid, 1401 schema->conf_type); 1402 if (r->rid == RDT_RESOURCE_MBA) 1403 size = ctrl; 1404 else 1405 size = rdtgroup_cbm_to_size(r, d, ctrl); 1406 } 1407 seq_printf(s, "%d=%u", d->id, size); 1408 sep = true; 1409 } 1410 seq_putc(s, '\n'); 1411 } 1412 1413 out: 1414 rdtgroup_kn_unlock(of->kn); 1415 1416 return ret; 1417 } 1418 1419 /* rdtgroup information files for one cache resource. */ 1420 static struct rftype res_common_files[] = { 1421 { 1422 .name = "last_cmd_status", 1423 .mode = 0444, 1424 .kf_ops = &rdtgroup_kf_single_ops, 1425 .seq_show = rdt_last_cmd_status_show, 1426 .fflags = RF_TOP_INFO, 1427 }, 1428 { 1429 .name = "num_closids", 1430 .mode = 0444, 1431 .kf_ops = &rdtgroup_kf_single_ops, 1432 .seq_show = rdt_num_closids_show, 1433 .fflags = RF_CTRL_INFO, 1434 }, 1435 { 1436 .name = "mon_features", 1437 .mode = 0444, 1438 .kf_ops = &rdtgroup_kf_single_ops, 1439 .seq_show = rdt_mon_features_show, 1440 .fflags = RF_MON_INFO, 1441 }, 1442 { 1443 .name = "num_rmids", 1444 .mode = 0444, 1445 .kf_ops = &rdtgroup_kf_single_ops, 1446 .seq_show = rdt_num_rmids_show, 1447 .fflags = RF_MON_INFO, 1448 }, 1449 { 1450 .name = "cbm_mask", 1451 .mode = 0444, 1452 .kf_ops = &rdtgroup_kf_single_ops, 1453 .seq_show = rdt_default_ctrl_show, 1454 .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1455 }, 1456 { 1457 .name = "min_cbm_bits", 1458 .mode = 0444, 1459 .kf_ops = &rdtgroup_kf_single_ops, 1460 .seq_show = rdt_min_cbm_bits_show, 1461 .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1462 }, 1463 { 1464 .name = "shareable_bits", 1465 .mode = 0444, 1466 .kf_ops = &rdtgroup_kf_single_ops, 1467 .seq_show = rdt_shareable_bits_show, 1468 .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1469 }, 1470 { 1471 .name = "bit_usage", 1472 .mode = 0444, 1473 .kf_ops = &rdtgroup_kf_single_ops, 1474 .seq_show = rdt_bit_usage_show, 1475 .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1476 }, 1477 { 1478 .name = "min_bandwidth", 1479 .mode = 0444, 1480 .kf_ops = &rdtgroup_kf_single_ops, 1481 .seq_show = rdt_min_bw_show, 1482 .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1483 }, 1484 { 1485 .name = "bandwidth_gran", 1486 .mode = 0444, 1487 .kf_ops = &rdtgroup_kf_single_ops, 1488 .seq_show = rdt_bw_gran_show, 1489 .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1490 }, 1491 { 1492 .name = "delay_linear", 1493 .mode = 0444, 1494 .kf_ops = &rdtgroup_kf_single_ops, 1495 .seq_show = rdt_delay_linear_show, 1496 .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1497 }, 1498 /* 1499 * Platform specific which (if any) capabilities are provided by 1500 * thread_throttle_mode. Defer "fflags" initialization to platform 1501 * discovery. 1502 */ 1503 { 1504 .name = "thread_throttle_mode", 1505 .mode = 0444, 1506 .kf_ops = &rdtgroup_kf_single_ops, 1507 .seq_show = rdt_thread_throttle_mode_show, 1508 }, 1509 { 1510 .name = "max_threshold_occupancy", 1511 .mode = 0644, 1512 .kf_ops = &rdtgroup_kf_single_ops, 1513 .write = max_threshold_occ_write, 1514 .seq_show = max_threshold_occ_show, 1515 .fflags = RF_MON_INFO | RFTYPE_RES_CACHE, 1516 }, 1517 { 1518 .name = "cpus", 1519 .mode = 0644, 1520 .kf_ops = &rdtgroup_kf_single_ops, 1521 .write = rdtgroup_cpus_write, 1522 .seq_show = rdtgroup_cpus_show, 1523 .fflags = RFTYPE_BASE, 1524 }, 1525 { 1526 .name = "cpus_list", 1527 .mode = 0644, 1528 .kf_ops = &rdtgroup_kf_single_ops, 1529 .write = rdtgroup_cpus_write, 1530 .seq_show = rdtgroup_cpus_show, 1531 .flags = RFTYPE_FLAGS_CPUS_LIST, 1532 .fflags = RFTYPE_BASE, 1533 }, 1534 { 1535 .name = "tasks", 1536 .mode = 0644, 1537 .kf_ops = &rdtgroup_kf_single_ops, 1538 .write = rdtgroup_tasks_write, 1539 .seq_show = rdtgroup_tasks_show, 1540 .fflags = RFTYPE_BASE, 1541 }, 1542 { 1543 .name = "schemata", 1544 .mode = 0644, 1545 .kf_ops = &rdtgroup_kf_single_ops, 1546 .write = rdtgroup_schemata_write, 1547 .seq_show = rdtgroup_schemata_show, 1548 .fflags = RF_CTRL_BASE, 1549 }, 1550 { 1551 .name = "mode", 1552 .mode = 0644, 1553 .kf_ops = &rdtgroup_kf_single_ops, 1554 .write = rdtgroup_mode_write, 1555 .seq_show = rdtgroup_mode_show, 1556 .fflags = RF_CTRL_BASE, 1557 }, 1558 { 1559 .name = "size", 1560 .mode = 0444, 1561 .kf_ops = &rdtgroup_kf_single_ops, 1562 .seq_show = rdtgroup_size_show, 1563 .fflags = RF_CTRL_BASE, 1564 }, 1565 1566 }; 1567 1568 static int rdtgroup_add_files(struct kernfs_node *kn, unsigned long fflags) 1569 { 1570 struct rftype *rfts, *rft; 1571 int ret, len; 1572 1573 rfts = res_common_files; 1574 len = ARRAY_SIZE(res_common_files); 1575 1576 lockdep_assert_held(&rdtgroup_mutex); 1577 1578 for (rft = rfts; rft < rfts + len; rft++) { 1579 if (rft->fflags && ((fflags & rft->fflags) == rft->fflags)) { 1580 ret = rdtgroup_add_file(kn, rft); 1581 if (ret) 1582 goto error; 1583 } 1584 } 1585 1586 return 0; 1587 error: 1588 pr_warn("Failed to add %s, err=%d\n", rft->name, ret); 1589 while (--rft >= rfts) { 1590 if ((fflags & rft->fflags) == rft->fflags) 1591 kernfs_remove_by_name(kn, rft->name); 1592 } 1593 return ret; 1594 } 1595 1596 static struct rftype *rdtgroup_get_rftype_by_name(const char *name) 1597 { 1598 struct rftype *rfts, *rft; 1599 int len; 1600 1601 rfts = res_common_files; 1602 len = ARRAY_SIZE(res_common_files); 1603 1604 for (rft = rfts; rft < rfts + len; rft++) { 1605 if (!strcmp(rft->name, name)) 1606 return rft; 1607 } 1608 1609 return NULL; 1610 } 1611 1612 void __init thread_throttle_mode_init(void) 1613 { 1614 struct rftype *rft; 1615 1616 rft = rdtgroup_get_rftype_by_name("thread_throttle_mode"); 1617 if (!rft) 1618 return; 1619 1620 rft->fflags = RF_CTRL_INFO | RFTYPE_RES_MB; 1621 } 1622 1623 /** 1624 * rdtgroup_kn_mode_restrict - Restrict user access to named resctrl file 1625 * @r: The resource group with which the file is associated. 1626 * @name: Name of the file 1627 * 1628 * The permissions of named resctrl file, directory, or link are modified 1629 * to not allow read, write, or execute by any user. 1630 * 1631 * WARNING: This function is intended to communicate to the user that the 1632 * resctrl file has been locked down - that it is not relevant to the 1633 * particular state the system finds itself in. It should not be relied 1634 * on to protect from user access because after the file's permissions 1635 * are restricted the user can still change the permissions using chmod 1636 * from the command line. 1637 * 1638 * Return: 0 on success, <0 on failure. 1639 */ 1640 int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name) 1641 { 1642 struct iattr iattr = {.ia_valid = ATTR_MODE,}; 1643 struct kernfs_node *kn; 1644 int ret = 0; 1645 1646 kn = kernfs_find_and_get_ns(r->kn, name, NULL); 1647 if (!kn) 1648 return -ENOENT; 1649 1650 switch (kernfs_type(kn)) { 1651 case KERNFS_DIR: 1652 iattr.ia_mode = S_IFDIR; 1653 break; 1654 case KERNFS_FILE: 1655 iattr.ia_mode = S_IFREG; 1656 break; 1657 case KERNFS_LINK: 1658 iattr.ia_mode = S_IFLNK; 1659 break; 1660 } 1661 1662 ret = kernfs_setattr(kn, &iattr); 1663 kernfs_put(kn); 1664 return ret; 1665 } 1666 1667 /** 1668 * rdtgroup_kn_mode_restore - Restore user access to named resctrl file 1669 * @r: The resource group with which the file is associated. 1670 * @name: Name of the file 1671 * @mask: Mask of permissions that should be restored 1672 * 1673 * Restore the permissions of the named file. If @name is a directory the 1674 * permissions of its parent will be used. 1675 * 1676 * Return: 0 on success, <0 on failure. 1677 */ 1678 int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, 1679 umode_t mask) 1680 { 1681 struct iattr iattr = {.ia_valid = ATTR_MODE,}; 1682 struct kernfs_node *kn, *parent; 1683 struct rftype *rfts, *rft; 1684 int ret, len; 1685 1686 rfts = res_common_files; 1687 len = ARRAY_SIZE(res_common_files); 1688 1689 for (rft = rfts; rft < rfts + len; rft++) { 1690 if (!strcmp(rft->name, name)) 1691 iattr.ia_mode = rft->mode & mask; 1692 } 1693 1694 kn = kernfs_find_and_get_ns(r->kn, name, NULL); 1695 if (!kn) 1696 return -ENOENT; 1697 1698 switch (kernfs_type(kn)) { 1699 case KERNFS_DIR: 1700 parent = kernfs_get_parent(kn); 1701 if (parent) { 1702 iattr.ia_mode |= parent->mode; 1703 kernfs_put(parent); 1704 } 1705 iattr.ia_mode |= S_IFDIR; 1706 break; 1707 case KERNFS_FILE: 1708 iattr.ia_mode |= S_IFREG; 1709 break; 1710 case KERNFS_LINK: 1711 iattr.ia_mode |= S_IFLNK; 1712 break; 1713 } 1714 1715 ret = kernfs_setattr(kn, &iattr); 1716 kernfs_put(kn); 1717 return ret; 1718 } 1719 1720 static int rdtgroup_mkdir_info_resdir(void *priv, char *name, 1721 unsigned long fflags) 1722 { 1723 struct kernfs_node *kn_subdir; 1724 int ret; 1725 1726 kn_subdir = kernfs_create_dir(kn_info, name, 1727 kn_info->mode, priv); 1728 if (IS_ERR(kn_subdir)) 1729 return PTR_ERR(kn_subdir); 1730 1731 ret = rdtgroup_kn_set_ugid(kn_subdir); 1732 if (ret) 1733 return ret; 1734 1735 ret = rdtgroup_add_files(kn_subdir, fflags); 1736 if (!ret) 1737 kernfs_activate(kn_subdir); 1738 1739 return ret; 1740 } 1741 1742 static int rdtgroup_create_info_dir(struct kernfs_node *parent_kn) 1743 { 1744 struct resctrl_schema *s; 1745 struct rdt_resource *r; 1746 unsigned long fflags; 1747 char name[32]; 1748 int ret; 1749 1750 /* create the directory */ 1751 kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL); 1752 if (IS_ERR(kn_info)) 1753 return PTR_ERR(kn_info); 1754 1755 ret = rdtgroup_add_files(kn_info, RF_TOP_INFO); 1756 if (ret) 1757 goto out_destroy; 1758 1759 /* loop over enabled controls, these are all alloc_capable */ 1760 list_for_each_entry(s, &resctrl_schema_all, list) { 1761 r = s->res; 1762 fflags = r->fflags | RF_CTRL_INFO; 1763 ret = rdtgroup_mkdir_info_resdir(s, s->name, fflags); 1764 if (ret) 1765 goto out_destroy; 1766 } 1767 1768 for_each_mon_capable_rdt_resource(r) { 1769 fflags = r->fflags | RF_MON_INFO; 1770 sprintf(name, "%s_MON", r->name); 1771 ret = rdtgroup_mkdir_info_resdir(r, name, fflags); 1772 if (ret) 1773 goto out_destroy; 1774 } 1775 1776 ret = rdtgroup_kn_set_ugid(kn_info); 1777 if (ret) 1778 goto out_destroy; 1779 1780 kernfs_activate(kn_info); 1781 1782 return 0; 1783 1784 out_destroy: 1785 kernfs_remove(kn_info); 1786 return ret; 1787 } 1788 1789 static int 1790 mongroup_create_dir(struct kernfs_node *parent_kn, struct rdtgroup *prgrp, 1791 char *name, struct kernfs_node **dest_kn) 1792 { 1793 struct kernfs_node *kn; 1794 int ret; 1795 1796 /* create the directory */ 1797 kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 1798 if (IS_ERR(kn)) 1799 return PTR_ERR(kn); 1800 1801 if (dest_kn) 1802 *dest_kn = kn; 1803 1804 ret = rdtgroup_kn_set_ugid(kn); 1805 if (ret) 1806 goto out_destroy; 1807 1808 kernfs_activate(kn); 1809 1810 return 0; 1811 1812 out_destroy: 1813 kernfs_remove(kn); 1814 return ret; 1815 } 1816 1817 static void l3_qos_cfg_update(void *arg) 1818 { 1819 bool *enable = arg; 1820 1821 wrmsrl(MSR_IA32_L3_QOS_CFG, *enable ? L3_QOS_CDP_ENABLE : 0ULL); 1822 } 1823 1824 static void l2_qos_cfg_update(void *arg) 1825 { 1826 bool *enable = arg; 1827 1828 wrmsrl(MSR_IA32_L2_QOS_CFG, *enable ? L2_QOS_CDP_ENABLE : 0ULL); 1829 } 1830 1831 static inline bool is_mba_linear(void) 1832 { 1833 return rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl.membw.delay_linear; 1834 } 1835 1836 static int set_cache_qos_cfg(int level, bool enable) 1837 { 1838 void (*update)(void *arg); 1839 struct rdt_resource *r_l; 1840 cpumask_var_t cpu_mask; 1841 struct rdt_domain *d; 1842 int cpu; 1843 1844 if (level == RDT_RESOURCE_L3) 1845 update = l3_qos_cfg_update; 1846 else if (level == RDT_RESOURCE_L2) 1847 update = l2_qos_cfg_update; 1848 else 1849 return -EINVAL; 1850 1851 if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL)) 1852 return -ENOMEM; 1853 1854 r_l = &rdt_resources_all[level].r_resctrl; 1855 list_for_each_entry(d, &r_l->domains, list) { 1856 if (r_l->cache.arch_has_per_cpu_cfg) 1857 /* Pick all the CPUs in the domain instance */ 1858 for_each_cpu(cpu, &d->cpu_mask) 1859 cpumask_set_cpu(cpu, cpu_mask); 1860 else 1861 /* Pick one CPU from each domain instance to update MSR */ 1862 cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask); 1863 } 1864 cpu = get_cpu(); 1865 /* Update QOS_CFG MSR on this cpu if it's in cpu_mask. */ 1866 if (cpumask_test_cpu(cpu, cpu_mask)) 1867 update(&enable); 1868 /* Update QOS_CFG MSR on all other cpus in cpu_mask. */ 1869 smp_call_function_many(cpu_mask, update, &enable, 1); 1870 put_cpu(); 1871 1872 free_cpumask_var(cpu_mask); 1873 1874 return 0; 1875 } 1876 1877 /* Restore the qos cfg state when a domain comes online */ 1878 void rdt_domain_reconfigure_cdp(struct rdt_resource *r) 1879 { 1880 struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 1881 1882 if (!r->cdp_capable) 1883 return; 1884 1885 if (r->rid == RDT_RESOURCE_L2) 1886 l2_qos_cfg_update(&hw_res->cdp_enabled); 1887 1888 if (r->rid == RDT_RESOURCE_L3) 1889 l3_qos_cfg_update(&hw_res->cdp_enabled); 1890 } 1891 1892 static int mba_sc_domain_allocate(struct rdt_resource *r, struct rdt_domain *d) 1893 { 1894 u32 num_closid = resctrl_arch_get_num_closid(r); 1895 int cpu = cpumask_any(&d->cpu_mask); 1896 int i; 1897 1898 d->mbps_val = kcalloc_node(num_closid, sizeof(*d->mbps_val), 1899 GFP_KERNEL, cpu_to_node(cpu)); 1900 if (!d->mbps_val) 1901 return -ENOMEM; 1902 1903 for (i = 0; i < num_closid; i++) 1904 d->mbps_val[i] = MBA_MAX_MBPS; 1905 1906 return 0; 1907 } 1908 1909 static void mba_sc_domain_destroy(struct rdt_resource *r, 1910 struct rdt_domain *d) 1911 { 1912 kfree(d->mbps_val); 1913 d->mbps_val = NULL; 1914 } 1915 1916 /* 1917 * MBA software controller is supported only if 1918 * MBM is supported and MBA is in linear scale. 1919 */ 1920 static bool supports_mba_mbps(void) 1921 { 1922 struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl; 1923 1924 return (is_mbm_local_enabled() && 1925 r->alloc_capable && is_mba_linear()); 1926 } 1927 1928 /* 1929 * Enable or disable the MBA software controller 1930 * which helps user specify bandwidth in MBps. 1931 */ 1932 static int set_mba_sc(bool mba_sc) 1933 { 1934 struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl; 1935 u32 num_closid = resctrl_arch_get_num_closid(r); 1936 struct rdt_domain *d; 1937 int i; 1938 1939 if (!supports_mba_mbps() || mba_sc == is_mba_sc(r)) 1940 return -EINVAL; 1941 1942 r->membw.mba_sc = mba_sc; 1943 1944 list_for_each_entry(d, &r->domains, list) { 1945 for (i = 0; i < num_closid; i++) 1946 d->mbps_val[i] = MBA_MAX_MBPS; 1947 } 1948 1949 return 0; 1950 } 1951 1952 static int cdp_enable(int level) 1953 { 1954 struct rdt_resource *r_l = &rdt_resources_all[level].r_resctrl; 1955 int ret; 1956 1957 if (!r_l->alloc_capable) 1958 return -EINVAL; 1959 1960 ret = set_cache_qos_cfg(level, true); 1961 if (!ret) 1962 rdt_resources_all[level].cdp_enabled = true; 1963 1964 return ret; 1965 } 1966 1967 static void cdp_disable(int level) 1968 { 1969 struct rdt_hw_resource *r_hw = &rdt_resources_all[level]; 1970 1971 if (r_hw->cdp_enabled) { 1972 set_cache_qos_cfg(level, false); 1973 r_hw->cdp_enabled = false; 1974 } 1975 } 1976 1977 int resctrl_arch_set_cdp_enabled(enum resctrl_res_level l, bool enable) 1978 { 1979 struct rdt_hw_resource *hw_res = &rdt_resources_all[l]; 1980 1981 if (!hw_res->r_resctrl.cdp_capable) 1982 return -EINVAL; 1983 1984 if (enable) 1985 return cdp_enable(l); 1986 1987 cdp_disable(l); 1988 1989 return 0; 1990 } 1991 1992 static void cdp_disable_all(void) 1993 { 1994 if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3)) 1995 resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, false); 1996 if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) 1997 resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, false); 1998 } 1999 2000 /* 2001 * We don't allow rdtgroup directories to be created anywhere 2002 * except the root directory. Thus when looking for the rdtgroup 2003 * structure for a kernfs node we are either looking at a directory, 2004 * in which case the rdtgroup structure is pointed at by the "priv" 2005 * field, otherwise we have a file, and need only look to the parent 2006 * to find the rdtgroup. 2007 */ 2008 static struct rdtgroup *kernfs_to_rdtgroup(struct kernfs_node *kn) 2009 { 2010 if (kernfs_type(kn) == KERNFS_DIR) { 2011 /* 2012 * All the resource directories use "kn->priv" 2013 * to point to the "struct rdtgroup" for the 2014 * resource. "info" and its subdirectories don't 2015 * have rdtgroup structures, so return NULL here. 2016 */ 2017 if (kn == kn_info || kn->parent == kn_info) 2018 return NULL; 2019 else 2020 return kn->priv; 2021 } else { 2022 return kn->parent->priv; 2023 } 2024 } 2025 2026 struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn) 2027 { 2028 struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2029 2030 if (!rdtgrp) 2031 return NULL; 2032 2033 atomic_inc(&rdtgrp->waitcount); 2034 kernfs_break_active_protection(kn); 2035 2036 mutex_lock(&rdtgroup_mutex); 2037 2038 /* Was this group deleted while we waited? */ 2039 if (rdtgrp->flags & RDT_DELETED) 2040 return NULL; 2041 2042 return rdtgrp; 2043 } 2044 2045 void rdtgroup_kn_unlock(struct kernfs_node *kn) 2046 { 2047 struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2048 2049 if (!rdtgrp) 2050 return; 2051 2052 mutex_unlock(&rdtgroup_mutex); 2053 2054 if (atomic_dec_and_test(&rdtgrp->waitcount) && 2055 (rdtgrp->flags & RDT_DELETED)) { 2056 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2057 rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2058 rdtgroup_pseudo_lock_remove(rdtgrp); 2059 kernfs_unbreak_active_protection(kn); 2060 rdtgroup_remove(rdtgrp); 2061 } else { 2062 kernfs_unbreak_active_protection(kn); 2063 } 2064 } 2065 2066 static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2067 struct rdtgroup *prgrp, 2068 struct kernfs_node **mon_data_kn); 2069 2070 static int rdt_enable_ctx(struct rdt_fs_context *ctx) 2071 { 2072 int ret = 0; 2073 2074 if (ctx->enable_cdpl2) 2075 ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, true); 2076 2077 if (!ret && ctx->enable_cdpl3) 2078 ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, true); 2079 2080 if (!ret && ctx->enable_mba_mbps) 2081 ret = set_mba_sc(true); 2082 2083 return ret; 2084 } 2085 2086 static int schemata_list_add(struct rdt_resource *r, enum resctrl_conf_type type) 2087 { 2088 struct resctrl_schema *s; 2089 const char *suffix = ""; 2090 int ret, cl; 2091 2092 s = kzalloc(sizeof(*s), GFP_KERNEL); 2093 if (!s) 2094 return -ENOMEM; 2095 2096 s->res = r; 2097 s->num_closid = resctrl_arch_get_num_closid(r); 2098 if (resctrl_arch_get_cdp_enabled(r->rid)) 2099 s->num_closid /= 2; 2100 2101 s->conf_type = type; 2102 switch (type) { 2103 case CDP_CODE: 2104 suffix = "CODE"; 2105 break; 2106 case CDP_DATA: 2107 suffix = "DATA"; 2108 break; 2109 case CDP_NONE: 2110 suffix = ""; 2111 break; 2112 } 2113 2114 ret = snprintf(s->name, sizeof(s->name), "%s%s", r->name, suffix); 2115 if (ret >= sizeof(s->name)) { 2116 kfree(s); 2117 return -EINVAL; 2118 } 2119 2120 cl = strlen(s->name); 2121 2122 /* 2123 * If CDP is supported by this resource, but not enabled, 2124 * include the suffix. This ensures the tabular format of the 2125 * schemata file does not change between mounts of the filesystem. 2126 */ 2127 if (r->cdp_capable && !resctrl_arch_get_cdp_enabled(r->rid)) 2128 cl += 4; 2129 2130 if (cl > max_name_width) 2131 max_name_width = cl; 2132 2133 INIT_LIST_HEAD(&s->list); 2134 list_add(&s->list, &resctrl_schema_all); 2135 2136 return 0; 2137 } 2138 2139 static int schemata_list_create(void) 2140 { 2141 struct rdt_resource *r; 2142 int ret = 0; 2143 2144 for_each_alloc_capable_rdt_resource(r) { 2145 if (resctrl_arch_get_cdp_enabled(r->rid)) { 2146 ret = schemata_list_add(r, CDP_CODE); 2147 if (ret) 2148 break; 2149 2150 ret = schemata_list_add(r, CDP_DATA); 2151 } else { 2152 ret = schemata_list_add(r, CDP_NONE); 2153 } 2154 2155 if (ret) 2156 break; 2157 } 2158 2159 return ret; 2160 } 2161 2162 static void schemata_list_destroy(void) 2163 { 2164 struct resctrl_schema *s, *tmp; 2165 2166 list_for_each_entry_safe(s, tmp, &resctrl_schema_all, list) { 2167 list_del(&s->list); 2168 kfree(s); 2169 } 2170 } 2171 2172 static int rdt_get_tree(struct fs_context *fc) 2173 { 2174 struct rdt_fs_context *ctx = rdt_fc2context(fc); 2175 struct rdt_domain *dom; 2176 struct rdt_resource *r; 2177 int ret; 2178 2179 cpus_read_lock(); 2180 mutex_lock(&rdtgroup_mutex); 2181 /* 2182 * resctrl file system can only be mounted once. 2183 */ 2184 if (static_branch_unlikely(&rdt_enable_key)) { 2185 ret = -EBUSY; 2186 goto out; 2187 } 2188 2189 ret = rdt_enable_ctx(ctx); 2190 if (ret < 0) 2191 goto out_cdp; 2192 2193 ret = schemata_list_create(); 2194 if (ret) { 2195 schemata_list_destroy(); 2196 goto out_mba; 2197 } 2198 2199 closid_init(); 2200 2201 ret = rdtgroup_create_info_dir(rdtgroup_default.kn); 2202 if (ret < 0) 2203 goto out_schemata_free; 2204 2205 if (rdt_mon_capable) { 2206 ret = mongroup_create_dir(rdtgroup_default.kn, 2207 &rdtgroup_default, "mon_groups", 2208 &kn_mongrp); 2209 if (ret < 0) 2210 goto out_info; 2211 2212 ret = mkdir_mondata_all(rdtgroup_default.kn, 2213 &rdtgroup_default, &kn_mondata); 2214 if (ret < 0) 2215 goto out_mongrp; 2216 rdtgroup_default.mon.mon_data_kn = kn_mondata; 2217 } 2218 2219 ret = rdt_pseudo_lock_init(); 2220 if (ret) 2221 goto out_mondata; 2222 2223 ret = kernfs_get_tree(fc); 2224 if (ret < 0) 2225 goto out_psl; 2226 2227 if (rdt_alloc_capable) 2228 static_branch_enable_cpuslocked(&rdt_alloc_enable_key); 2229 if (rdt_mon_capable) 2230 static_branch_enable_cpuslocked(&rdt_mon_enable_key); 2231 2232 if (rdt_alloc_capable || rdt_mon_capable) 2233 static_branch_enable_cpuslocked(&rdt_enable_key); 2234 2235 if (is_mbm_enabled()) { 2236 r = &rdt_resources_all[RDT_RESOURCE_L3].r_resctrl; 2237 list_for_each_entry(dom, &r->domains, list) 2238 mbm_setup_overflow_handler(dom, MBM_OVERFLOW_INTERVAL); 2239 } 2240 2241 goto out; 2242 2243 out_psl: 2244 rdt_pseudo_lock_release(); 2245 out_mondata: 2246 if (rdt_mon_capable) 2247 kernfs_remove(kn_mondata); 2248 out_mongrp: 2249 if (rdt_mon_capable) 2250 kernfs_remove(kn_mongrp); 2251 out_info: 2252 kernfs_remove(kn_info); 2253 out_schemata_free: 2254 schemata_list_destroy(); 2255 out_mba: 2256 if (ctx->enable_mba_mbps) 2257 set_mba_sc(false); 2258 out_cdp: 2259 cdp_disable_all(); 2260 out: 2261 rdt_last_cmd_clear(); 2262 mutex_unlock(&rdtgroup_mutex); 2263 cpus_read_unlock(); 2264 return ret; 2265 } 2266 2267 enum rdt_param { 2268 Opt_cdp, 2269 Opt_cdpl2, 2270 Opt_mba_mbps, 2271 nr__rdt_params 2272 }; 2273 2274 static const struct fs_parameter_spec rdt_fs_parameters[] = { 2275 fsparam_flag("cdp", Opt_cdp), 2276 fsparam_flag("cdpl2", Opt_cdpl2), 2277 fsparam_flag("mba_MBps", Opt_mba_mbps), 2278 {} 2279 }; 2280 2281 static int rdt_parse_param(struct fs_context *fc, struct fs_parameter *param) 2282 { 2283 struct rdt_fs_context *ctx = rdt_fc2context(fc); 2284 struct fs_parse_result result; 2285 int opt; 2286 2287 opt = fs_parse(fc, rdt_fs_parameters, param, &result); 2288 if (opt < 0) 2289 return opt; 2290 2291 switch (opt) { 2292 case Opt_cdp: 2293 ctx->enable_cdpl3 = true; 2294 return 0; 2295 case Opt_cdpl2: 2296 ctx->enable_cdpl2 = true; 2297 return 0; 2298 case Opt_mba_mbps: 2299 if (!supports_mba_mbps()) 2300 return -EINVAL; 2301 ctx->enable_mba_mbps = true; 2302 return 0; 2303 } 2304 2305 return -EINVAL; 2306 } 2307 2308 static void rdt_fs_context_free(struct fs_context *fc) 2309 { 2310 struct rdt_fs_context *ctx = rdt_fc2context(fc); 2311 2312 kernfs_free_fs_context(fc); 2313 kfree(ctx); 2314 } 2315 2316 static const struct fs_context_operations rdt_fs_context_ops = { 2317 .free = rdt_fs_context_free, 2318 .parse_param = rdt_parse_param, 2319 .get_tree = rdt_get_tree, 2320 }; 2321 2322 static int rdt_init_fs_context(struct fs_context *fc) 2323 { 2324 struct rdt_fs_context *ctx; 2325 2326 ctx = kzalloc(sizeof(struct rdt_fs_context), GFP_KERNEL); 2327 if (!ctx) 2328 return -ENOMEM; 2329 2330 ctx->kfc.root = rdt_root; 2331 ctx->kfc.magic = RDTGROUP_SUPER_MAGIC; 2332 fc->fs_private = &ctx->kfc; 2333 fc->ops = &rdt_fs_context_ops; 2334 put_user_ns(fc->user_ns); 2335 fc->user_ns = get_user_ns(&init_user_ns); 2336 fc->global = true; 2337 return 0; 2338 } 2339 2340 static int reset_all_ctrls(struct rdt_resource *r) 2341 { 2342 struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 2343 struct rdt_hw_domain *hw_dom; 2344 struct msr_param msr_param; 2345 cpumask_var_t cpu_mask; 2346 struct rdt_domain *d; 2347 int i, cpu; 2348 2349 if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL)) 2350 return -ENOMEM; 2351 2352 msr_param.res = r; 2353 msr_param.low = 0; 2354 msr_param.high = hw_res->num_closid; 2355 2356 /* 2357 * Disable resource control for this resource by setting all 2358 * CBMs in all domains to the maximum mask value. Pick one CPU 2359 * from each domain to update the MSRs below. 2360 */ 2361 list_for_each_entry(d, &r->domains, list) { 2362 hw_dom = resctrl_to_arch_dom(d); 2363 cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask); 2364 2365 for (i = 0; i < hw_res->num_closid; i++) { 2366 hw_dom->ctrl_val[i] = r->default_ctrl; 2367 hw_dom->mbps_val[i] = MBA_MAX_MBPS; 2368 } 2369 } 2370 cpu = get_cpu(); 2371 /* Update CBM on this cpu if it's in cpu_mask. */ 2372 if (cpumask_test_cpu(cpu, cpu_mask)) 2373 rdt_ctrl_update(&msr_param); 2374 /* Update CBM on all other cpus in cpu_mask. */ 2375 smp_call_function_many(cpu_mask, rdt_ctrl_update, &msr_param, 1); 2376 put_cpu(); 2377 2378 free_cpumask_var(cpu_mask); 2379 2380 return 0; 2381 } 2382 2383 /* 2384 * Move tasks from one to the other group. If @from is NULL, then all tasks 2385 * in the systems are moved unconditionally (used for teardown). 2386 * 2387 * If @mask is not NULL the cpus on which moved tasks are running are set 2388 * in that mask so the update smp function call is restricted to affected 2389 * cpus. 2390 */ 2391 static void rdt_move_group_tasks(struct rdtgroup *from, struct rdtgroup *to, 2392 struct cpumask *mask) 2393 { 2394 struct task_struct *p, *t; 2395 2396 read_lock(&tasklist_lock); 2397 for_each_process_thread(p, t) { 2398 if (!from || is_closid_match(t, from) || 2399 is_rmid_match(t, from)) { 2400 WRITE_ONCE(t->closid, to->closid); 2401 WRITE_ONCE(t->rmid, to->mon.rmid); 2402 2403 /* 2404 * If the task is on a CPU, set the CPU in the mask. 2405 * The detection is inaccurate as tasks might move or 2406 * schedule before the smp function call takes place. 2407 * In such a case the function call is pointless, but 2408 * there is no other side effect. 2409 */ 2410 if (IS_ENABLED(CONFIG_SMP) && mask && task_curr(t)) 2411 cpumask_set_cpu(task_cpu(t), mask); 2412 } 2413 } 2414 read_unlock(&tasklist_lock); 2415 } 2416 2417 static void free_all_child_rdtgrp(struct rdtgroup *rdtgrp) 2418 { 2419 struct rdtgroup *sentry, *stmp; 2420 struct list_head *head; 2421 2422 head = &rdtgrp->mon.crdtgrp_list; 2423 list_for_each_entry_safe(sentry, stmp, head, mon.crdtgrp_list) { 2424 free_rmid(sentry->mon.rmid); 2425 list_del(&sentry->mon.crdtgrp_list); 2426 2427 if (atomic_read(&sentry->waitcount) != 0) 2428 sentry->flags = RDT_DELETED; 2429 else 2430 rdtgroup_remove(sentry); 2431 } 2432 } 2433 2434 /* 2435 * Forcibly remove all of subdirectories under root. 2436 */ 2437 static void rmdir_all_sub(void) 2438 { 2439 struct rdtgroup *rdtgrp, *tmp; 2440 2441 /* Move all tasks to the default resource group */ 2442 rdt_move_group_tasks(NULL, &rdtgroup_default, NULL); 2443 2444 list_for_each_entry_safe(rdtgrp, tmp, &rdt_all_groups, rdtgroup_list) { 2445 /* Free any child rmids */ 2446 free_all_child_rdtgrp(rdtgrp); 2447 2448 /* Remove each rdtgroup other than root */ 2449 if (rdtgrp == &rdtgroup_default) 2450 continue; 2451 2452 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2453 rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2454 rdtgroup_pseudo_lock_remove(rdtgrp); 2455 2456 /* 2457 * Give any CPUs back to the default group. We cannot copy 2458 * cpu_online_mask because a CPU might have executed the 2459 * offline callback already, but is still marked online. 2460 */ 2461 cpumask_or(&rdtgroup_default.cpu_mask, 2462 &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 2463 2464 free_rmid(rdtgrp->mon.rmid); 2465 2466 kernfs_remove(rdtgrp->kn); 2467 list_del(&rdtgrp->rdtgroup_list); 2468 2469 if (atomic_read(&rdtgrp->waitcount) != 0) 2470 rdtgrp->flags = RDT_DELETED; 2471 else 2472 rdtgroup_remove(rdtgrp); 2473 } 2474 /* Notify online CPUs to update per cpu storage and PQR_ASSOC MSR */ 2475 update_closid_rmid(cpu_online_mask, &rdtgroup_default); 2476 2477 kernfs_remove(kn_info); 2478 kernfs_remove(kn_mongrp); 2479 kernfs_remove(kn_mondata); 2480 } 2481 2482 static void rdt_kill_sb(struct super_block *sb) 2483 { 2484 struct rdt_resource *r; 2485 2486 cpus_read_lock(); 2487 mutex_lock(&rdtgroup_mutex); 2488 2489 set_mba_sc(false); 2490 2491 /*Put everything back to default values. */ 2492 for_each_alloc_capable_rdt_resource(r) 2493 reset_all_ctrls(r); 2494 cdp_disable_all(); 2495 rmdir_all_sub(); 2496 rdt_pseudo_lock_release(); 2497 rdtgroup_default.mode = RDT_MODE_SHAREABLE; 2498 schemata_list_destroy(); 2499 static_branch_disable_cpuslocked(&rdt_alloc_enable_key); 2500 static_branch_disable_cpuslocked(&rdt_mon_enable_key); 2501 static_branch_disable_cpuslocked(&rdt_enable_key); 2502 kernfs_kill_sb(sb); 2503 mutex_unlock(&rdtgroup_mutex); 2504 cpus_read_unlock(); 2505 } 2506 2507 static struct file_system_type rdt_fs_type = { 2508 .name = "resctrl", 2509 .init_fs_context = rdt_init_fs_context, 2510 .parameters = rdt_fs_parameters, 2511 .kill_sb = rdt_kill_sb, 2512 }; 2513 2514 static int mon_addfile(struct kernfs_node *parent_kn, const char *name, 2515 void *priv) 2516 { 2517 struct kernfs_node *kn; 2518 int ret = 0; 2519 2520 kn = __kernfs_create_file(parent_kn, name, 0444, 2521 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 0, 2522 &kf_mondata_ops, priv, NULL, NULL); 2523 if (IS_ERR(kn)) 2524 return PTR_ERR(kn); 2525 2526 ret = rdtgroup_kn_set_ugid(kn); 2527 if (ret) { 2528 kernfs_remove(kn); 2529 return ret; 2530 } 2531 2532 return ret; 2533 } 2534 2535 /* 2536 * Remove all subdirectories of mon_data of ctrl_mon groups 2537 * and monitor groups with given domain id. 2538 */ 2539 static void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 2540 unsigned int dom_id) 2541 { 2542 struct rdtgroup *prgrp, *crgrp; 2543 char name[32]; 2544 2545 list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 2546 sprintf(name, "mon_%s_%02d", r->name, dom_id); 2547 kernfs_remove_by_name(prgrp->mon.mon_data_kn, name); 2548 2549 list_for_each_entry(crgrp, &prgrp->mon.crdtgrp_list, mon.crdtgrp_list) 2550 kernfs_remove_by_name(crgrp->mon.mon_data_kn, name); 2551 } 2552 } 2553 2554 static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, 2555 struct rdt_domain *d, 2556 struct rdt_resource *r, struct rdtgroup *prgrp) 2557 { 2558 union mon_data_bits priv; 2559 struct kernfs_node *kn; 2560 struct mon_evt *mevt; 2561 struct rmid_read rr; 2562 char name[32]; 2563 int ret; 2564 2565 sprintf(name, "mon_%s_%02d", r->name, d->id); 2566 /* create the directory */ 2567 kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 2568 if (IS_ERR(kn)) 2569 return PTR_ERR(kn); 2570 2571 ret = rdtgroup_kn_set_ugid(kn); 2572 if (ret) 2573 goto out_destroy; 2574 2575 if (WARN_ON(list_empty(&r->evt_list))) { 2576 ret = -EPERM; 2577 goto out_destroy; 2578 } 2579 2580 priv.u.rid = r->rid; 2581 priv.u.domid = d->id; 2582 list_for_each_entry(mevt, &r->evt_list, list) { 2583 priv.u.evtid = mevt->evtid; 2584 ret = mon_addfile(kn, mevt->name, priv.priv); 2585 if (ret) 2586 goto out_destroy; 2587 2588 if (is_mbm_event(mevt->evtid)) 2589 mon_event_read(&rr, r, d, prgrp, mevt->evtid, true); 2590 } 2591 kernfs_activate(kn); 2592 return 0; 2593 2594 out_destroy: 2595 kernfs_remove(kn); 2596 return ret; 2597 } 2598 2599 /* 2600 * Add all subdirectories of mon_data for "ctrl_mon" groups 2601 * and "monitor" groups with given domain id. 2602 */ 2603 static void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 2604 struct rdt_domain *d) 2605 { 2606 struct kernfs_node *parent_kn; 2607 struct rdtgroup *prgrp, *crgrp; 2608 struct list_head *head; 2609 2610 list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 2611 parent_kn = prgrp->mon.mon_data_kn; 2612 mkdir_mondata_subdir(parent_kn, d, r, prgrp); 2613 2614 head = &prgrp->mon.crdtgrp_list; 2615 list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 2616 parent_kn = crgrp->mon.mon_data_kn; 2617 mkdir_mondata_subdir(parent_kn, d, r, crgrp); 2618 } 2619 } 2620 } 2621 2622 static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, 2623 struct rdt_resource *r, 2624 struct rdtgroup *prgrp) 2625 { 2626 struct rdt_domain *dom; 2627 int ret; 2628 2629 list_for_each_entry(dom, &r->domains, list) { 2630 ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp); 2631 if (ret) 2632 return ret; 2633 } 2634 2635 return 0; 2636 } 2637 2638 /* 2639 * This creates a directory mon_data which contains the monitored data. 2640 * 2641 * mon_data has one directory for each domain which are named 2642 * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data 2643 * with L3 domain looks as below: 2644 * ./mon_data: 2645 * mon_L3_00 2646 * mon_L3_01 2647 * mon_L3_02 2648 * ... 2649 * 2650 * Each domain directory has one file per event: 2651 * ./mon_L3_00/: 2652 * llc_occupancy 2653 * 2654 */ 2655 static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2656 struct rdtgroup *prgrp, 2657 struct kernfs_node **dest_kn) 2658 { 2659 struct rdt_resource *r; 2660 struct kernfs_node *kn; 2661 int ret; 2662 2663 /* 2664 * Create the mon_data directory first. 2665 */ 2666 ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn); 2667 if (ret) 2668 return ret; 2669 2670 if (dest_kn) 2671 *dest_kn = kn; 2672 2673 /* 2674 * Create the subdirectories for each domain. Note that all events 2675 * in a domain like L3 are grouped into a resource whose domain is L3 2676 */ 2677 for_each_mon_capable_rdt_resource(r) { 2678 ret = mkdir_mondata_subdir_alldom(kn, r, prgrp); 2679 if (ret) 2680 goto out_destroy; 2681 } 2682 2683 return 0; 2684 2685 out_destroy: 2686 kernfs_remove(kn); 2687 return ret; 2688 } 2689 2690 /** 2691 * cbm_ensure_valid - Enforce validity on provided CBM 2692 * @_val: Candidate CBM 2693 * @r: RDT resource to which the CBM belongs 2694 * 2695 * The provided CBM represents all cache portions available for use. This 2696 * may be represented by a bitmap that does not consist of contiguous ones 2697 * and thus be an invalid CBM. 2698 * Here the provided CBM is forced to be a valid CBM by only considering 2699 * the first set of contiguous bits as valid and clearing all bits. 2700 * The intention here is to provide a valid default CBM with which a new 2701 * resource group is initialized. The user can follow this with a 2702 * modification to the CBM if the default does not satisfy the 2703 * requirements. 2704 */ 2705 static u32 cbm_ensure_valid(u32 _val, struct rdt_resource *r) 2706 { 2707 unsigned int cbm_len = r->cache.cbm_len; 2708 unsigned long first_bit, zero_bit; 2709 unsigned long val = _val; 2710 2711 if (!val) 2712 return 0; 2713 2714 first_bit = find_first_bit(&val, cbm_len); 2715 zero_bit = find_next_zero_bit(&val, cbm_len, first_bit); 2716 2717 /* Clear any remaining bits to ensure contiguous region */ 2718 bitmap_clear(&val, zero_bit, cbm_len - zero_bit); 2719 return (u32)val; 2720 } 2721 2722 /* 2723 * Initialize cache resources per RDT domain 2724 * 2725 * Set the RDT domain up to start off with all usable allocations. That is, 2726 * all shareable and unused bits. All-zero CBM is invalid. 2727 */ 2728 static int __init_one_rdt_domain(struct rdt_domain *d, struct resctrl_schema *s, 2729 u32 closid) 2730 { 2731 enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 2732 enum resctrl_conf_type t = s->conf_type; 2733 struct resctrl_staged_config *cfg; 2734 struct rdt_resource *r = s->res; 2735 u32 used_b = 0, unused_b = 0; 2736 unsigned long tmp_cbm; 2737 enum rdtgrp_mode mode; 2738 u32 peer_ctl, ctrl_val; 2739 int i; 2740 2741 cfg = &d->staged_config[t]; 2742 cfg->have_new_ctrl = false; 2743 cfg->new_ctrl = r->cache.shareable_bits; 2744 used_b = r->cache.shareable_bits; 2745 for (i = 0; i < closids_supported(); i++) { 2746 if (closid_allocated(i) && i != closid) { 2747 mode = rdtgroup_mode_by_closid(i); 2748 if (mode == RDT_MODE_PSEUDO_LOCKSETUP) 2749 /* 2750 * ctrl values for locksetup aren't relevant 2751 * until the schemata is written, and the mode 2752 * becomes RDT_MODE_PSEUDO_LOCKED. 2753 */ 2754 continue; 2755 /* 2756 * If CDP is active include peer domain's 2757 * usage to ensure there is no overlap 2758 * with an exclusive group. 2759 */ 2760 if (resctrl_arch_get_cdp_enabled(r->rid)) 2761 peer_ctl = resctrl_arch_get_config(r, d, i, 2762 peer_type); 2763 else 2764 peer_ctl = 0; 2765 ctrl_val = resctrl_arch_get_config(r, d, i, 2766 s->conf_type); 2767 used_b |= ctrl_val | peer_ctl; 2768 if (mode == RDT_MODE_SHAREABLE) 2769 cfg->new_ctrl |= ctrl_val | peer_ctl; 2770 } 2771 } 2772 if (d->plr && d->plr->cbm > 0) 2773 used_b |= d->plr->cbm; 2774 unused_b = used_b ^ (BIT_MASK(r->cache.cbm_len) - 1); 2775 unused_b &= BIT_MASK(r->cache.cbm_len) - 1; 2776 cfg->new_ctrl |= unused_b; 2777 /* 2778 * Force the initial CBM to be valid, user can 2779 * modify the CBM based on system availability. 2780 */ 2781 cfg->new_ctrl = cbm_ensure_valid(cfg->new_ctrl, r); 2782 /* 2783 * Assign the u32 CBM to an unsigned long to ensure that 2784 * bitmap_weight() does not access out-of-bound memory. 2785 */ 2786 tmp_cbm = cfg->new_ctrl; 2787 if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) { 2788 rdt_last_cmd_printf("No space on %s:%d\n", s->name, d->id); 2789 return -ENOSPC; 2790 } 2791 cfg->have_new_ctrl = true; 2792 2793 return 0; 2794 } 2795 2796 /* 2797 * Initialize cache resources with default values. 2798 * 2799 * A new RDT group is being created on an allocation capable (CAT) 2800 * supporting system. Set this group up to start off with all usable 2801 * allocations. 2802 * 2803 * If there are no more shareable bits available on any domain then 2804 * the entire allocation will fail. 2805 */ 2806 static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) 2807 { 2808 struct rdt_domain *d; 2809 int ret; 2810 2811 list_for_each_entry(d, &s->res->domains, list) { 2812 ret = __init_one_rdt_domain(d, s, closid); 2813 if (ret < 0) 2814 return ret; 2815 } 2816 2817 return 0; 2818 } 2819 2820 /* Initialize MBA resource with default values. */ 2821 static void rdtgroup_init_mba(struct rdt_resource *r) 2822 { 2823 struct resctrl_staged_config *cfg; 2824 struct rdt_domain *d; 2825 2826 list_for_each_entry(d, &r->domains, list) { 2827 cfg = &d->staged_config[CDP_NONE]; 2828 cfg->new_ctrl = is_mba_sc(r) ? MBA_MAX_MBPS : r->default_ctrl; 2829 cfg->have_new_ctrl = true; 2830 } 2831 } 2832 2833 /* Initialize the RDT group's allocations. */ 2834 static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp) 2835 { 2836 struct resctrl_schema *s; 2837 struct rdt_resource *r; 2838 int ret; 2839 2840 list_for_each_entry(s, &resctrl_schema_all, list) { 2841 r = s->res; 2842 if (r->rid == RDT_RESOURCE_MBA) { 2843 rdtgroup_init_mba(r); 2844 } else { 2845 ret = rdtgroup_init_cat(s, rdtgrp->closid); 2846 if (ret < 0) 2847 return ret; 2848 } 2849 2850 ret = resctrl_arch_update_domains(r, rdtgrp->closid); 2851 if (ret < 0) { 2852 rdt_last_cmd_puts("Failed to initialize allocations\n"); 2853 return ret; 2854 } 2855 2856 } 2857 2858 rdtgrp->mode = RDT_MODE_SHAREABLE; 2859 2860 return 0; 2861 } 2862 2863 static int mkdir_rdt_prepare(struct kernfs_node *parent_kn, 2864 const char *name, umode_t mode, 2865 enum rdt_group_type rtype, struct rdtgroup **r) 2866 { 2867 struct rdtgroup *prdtgrp, *rdtgrp; 2868 struct kernfs_node *kn; 2869 uint files = 0; 2870 int ret; 2871 2872 prdtgrp = rdtgroup_kn_lock_live(parent_kn); 2873 if (!prdtgrp) { 2874 ret = -ENODEV; 2875 goto out_unlock; 2876 } 2877 2878 if (rtype == RDTMON_GROUP && 2879 (prdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2880 prdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)) { 2881 ret = -EINVAL; 2882 rdt_last_cmd_puts("Pseudo-locking in progress\n"); 2883 goto out_unlock; 2884 } 2885 2886 /* allocate the rdtgroup. */ 2887 rdtgrp = kzalloc(sizeof(*rdtgrp), GFP_KERNEL); 2888 if (!rdtgrp) { 2889 ret = -ENOSPC; 2890 rdt_last_cmd_puts("Kernel out of memory\n"); 2891 goto out_unlock; 2892 } 2893 *r = rdtgrp; 2894 rdtgrp->mon.parent = prdtgrp; 2895 rdtgrp->type = rtype; 2896 INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list); 2897 2898 /* kernfs creates the directory for rdtgrp */ 2899 kn = kernfs_create_dir(parent_kn, name, mode, rdtgrp); 2900 if (IS_ERR(kn)) { 2901 ret = PTR_ERR(kn); 2902 rdt_last_cmd_puts("kernfs create error\n"); 2903 goto out_free_rgrp; 2904 } 2905 rdtgrp->kn = kn; 2906 2907 /* 2908 * kernfs_remove() will drop the reference count on "kn" which 2909 * will free it. But we still need it to stick around for the 2910 * rdtgroup_kn_unlock(kn) call. Take one extra reference here, 2911 * which will be dropped by kernfs_put() in rdtgroup_remove(). 2912 */ 2913 kernfs_get(kn); 2914 2915 ret = rdtgroup_kn_set_ugid(kn); 2916 if (ret) { 2917 rdt_last_cmd_puts("kernfs perm error\n"); 2918 goto out_destroy; 2919 } 2920 2921 files = RFTYPE_BASE | BIT(RF_CTRLSHIFT + rtype); 2922 ret = rdtgroup_add_files(kn, files); 2923 if (ret) { 2924 rdt_last_cmd_puts("kernfs fill error\n"); 2925 goto out_destroy; 2926 } 2927 2928 if (rdt_mon_capable) { 2929 ret = alloc_rmid(); 2930 if (ret < 0) { 2931 rdt_last_cmd_puts("Out of RMIDs\n"); 2932 goto out_destroy; 2933 } 2934 rdtgrp->mon.rmid = ret; 2935 2936 ret = mkdir_mondata_all(kn, rdtgrp, &rdtgrp->mon.mon_data_kn); 2937 if (ret) { 2938 rdt_last_cmd_puts("kernfs subdir error\n"); 2939 goto out_idfree; 2940 } 2941 } 2942 kernfs_activate(kn); 2943 2944 /* 2945 * The caller unlocks the parent_kn upon success. 2946 */ 2947 return 0; 2948 2949 out_idfree: 2950 free_rmid(rdtgrp->mon.rmid); 2951 out_destroy: 2952 kernfs_put(rdtgrp->kn); 2953 kernfs_remove(rdtgrp->kn); 2954 out_free_rgrp: 2955 kfree(rdtgrp); 2956 out_unlock: 2957 rdtgroup_kn_unlock(parent_kn); 2958 return ret; 2959 } 2960 2961 static void mkdir_rdt_prepare_clean(struct rdtgroup *rgrp) 2962 { 2963 kernfs_remove(rgrp->kn); 2964 free_rmid(rgrp->mon.rmid); 2965 rdtgroup_remove(rgrp); 2966 } 2967 2968 /* 2969 * Create a monitor group under "mon_groups" directory of a control 2970 * and monitor group(ctrl_mon). This is a resource group 2971 * to monitor a subset of tasks and cpus in its parent ctrl_mon group. 2972 */ 2973 static int rdtgroup_mkdir_mon(struct kernfs_node *parent_kn, 2974 const char *name, umode_t mode) 2975 { 2976 struct rdtgroup *rdtgrp, *prgrp; 2977 int ret; 2978 2979 ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTMON_GROUP, &rdtgrp); 2980 if (ret) 2981 return ret; 2982 2983 prgrp = rdtgrp->mon.parent; 2984 rdtgrp->closid = prgrp->closid; 2985 2986 /* 2987 * Add the rdtgrp to the list of rdtgrps the parent 2988 * ctrl_mon group has to track. 2989 */ 2990 list_add_tail(&rdtgrp->mon.crdtgrp_list, &prgrp->mon.crdtgrp_list); 2991 2992 rdtgroup_kn_unlock(parent_kn); 2993 return ret; 2994 } 2995 2996 /* 2997 * These are rdtgroups created under the root directory. Can be used 2998 * to allocate and monitor resources. 2999 */ 3000 static int rdtgroup_mkdir_ctrl_mon(struct kernfs_node *parent_kn, 3001 const char *name, umode_t mode) 3002 { 3003 struct rdtgroup *rdtgrp; 3004 struct kernfs_node *kn; 3005 u32 closid; 3006 int ret; 3007 3008 ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTCTRL_GROUP, &rdtgrp); 3009 if (ret) 3010 return ret; 3011 3012 kn = rdtgrp->kn; 3013 ret = closid_alloc(); 3014 if (ret < 0) { 3015 rdt_last_cmd_puts("Out of CLOSIDs\n"); 3016 goto out_common_fail; 3017 } 3018 closid = ret; 3019 ret = 0; 3020 3021 rdtgrp->closid = closid; 3022 ret = rdtgroup_init_alloc(rdtgrp); 3023 if (ret < 0) 3024 goto out_id_free; 3025 3026 list_add(&rdtgrp->rdtgroup_list, &rdt_all_groups); 3027 3028 if (rdt_mon_capable) { 3029 /* 3030 * Create an empty mon_groups directory to hold the subset 3031 * of tasks and cpus to monitor. 3032 */ 3033 ret = mongroup_create_dir(kn, rdtgrp, "mon_groups", NULL); 3034 if (ret) { 3035 rdt_last_cmd_puts("kernfs subdir error\n"); 3036 goto out_del_list; 3037 } 3038 } 3039 3040 goto out_unlock; 3041 3042 out_del_list: 3043 list_del(&rdtgrp->rdtgroup_list); 3044 out_id_free: 3045 closid_free(closid); 3046 out_common_fail: 3047 mkdir_rdt_prepare_clean(rdtgrp); 3048 out_unlock: 3049 rdtgroup_kn_unlock(parent_kn); 3050 return ret; 3051 } 3052 3053 /* 3054 * We allow creating mon groups only with in a directory called "mon_groups" 3055 * which is present in every ctrl_mon group. Check if this is a valid 3056 * "mon_groups" directory. 3057 * 3058 * 1. The directory should be named "mon_groups". 3059 * 2. The mon group itself should "not" be named "mon_groups". 3060 * This makes sure "mon_groups" directory always has a ctrl_mon group 3061 * as parent. 3062 */ 3063 static bool is_mon_groups(struct kernfs_node *kn, const char *name) 3064 { 3065 return (!strcmp(kn->name, "mon_groups") && 3066 strcmp(name, "mon_groups")); 3067 } 3068 3069 static int rdtgroup_mkdir(struct kernfs_node *parent_kn, const char *name, 3070 umode_t mode) 3071 { 3072 /* Do not accept '\n' to avoid unparsable situation. */ 3073 if (strchr(name, '\n')) 3074 return -EINVAL; 3075 3076 /* 3077 * If the parent directory is the root directory and RDT 3078 * allocation is supported, add a control and monitoring 3079 * subdirectory 3080 */ 3081 if (rdt_alloc_capable && parent_kn == rdtgroup_default.kn) 3082 return rdtgroup_mkdir_ctrl_mon(parent_kn, name, mode); 3083 3084 /* 3085 * If RDT monitoring is supported and the parent directory is a valid 3086 * "mon_groups" directory, add a monitoring subdirectory. 3087 */ 3088 if (rdt_mon_capable && is_mon_groups(parent_kn, name)) 3089 return rdtgroup_mkdir_mon(parent_kn, name, mode); 3090 3091 return -EPERM; 3092 } 3093 3094 static int rdtgroup_rmdir_mon(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3095 { 3096 struct rdtgroup *prdtgrp = rdtgrp->mon.parent; 3097 int cpu; 3098 3099 /* Give any tasks back to the parent group */ 3100 rdt_move_group_tasks(rdtgrp, prdtgrp, tmpmask); 3101 3102 /* Update per cpu rmid of the moved CPUs first */ 3103 for_each_cpu(cpu, &rdtgrp->cpu_mask) 3104 per_cpu(pqr_state.default_rmid, cpu) = prdtgrp->mon.rmid; 3105 /* 3106 * Update the MSR on moved CPUs and CPUs which have moved 3107 * task running on them. 3108 */ 3109 cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3110 update_closid_rmid(tmpmask, NULL); 3111 3112 rdtgrp->flags = RDT_DELETED; 3113 free_rmid(rdtgrp->mon.rmid); 3114 3115 /* 3116 * Remove the rdtgrp from the parent ctrl_mon group's list 3117 */ 3118 WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list)); 3119 list_del(&rdtgrp->mon.crdtgrp_list); 3120 3121 kernfs_remove(rdtgrp->kn); 3122 3123 return 0; 3124 } 3125 3126 static int rdtgroup_ctrl_remove(struct rdtgroup *rdtgrp) 3127 { 3128 rdtgrp->flags = RDT_DELETED; 3129 list_del(&rdtgrp->rdtgroup_list); 3130 3131 kernfs_remove(rdtgrp->kn); 3132 return 0; 3133 } 3134 3135 static int rdtgroup_rmdir_ctrl(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3136 { 3137 int cpu; 3138 3139 /* Give any tasks back to the default group */ 3140 rdt_move_group_tasks(rdtgrp, &rdtgroup_default, tmpmask); 3141 3142 /* Give any CPUs back to the default group */ 3143 cpumask_or(&rdtgroup_default.cpu_mask, 3144 &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 3145 3146 /* Update per cpu closid and rmid of the moved CPUs first */ 3147 for_each_cpu(cpu, &rdtgrp->cpu_mask) { 3148 per_cpu(pqr_state.default_closid, cpu) = rdtgroup_default.closid; 3149 per_cpu(pqr_state.default_rmid, cpu) = rdtgroup_default.mon.rmid; 3150 } 3151 3152 /* 3153 * Update the MSR on moved CPUs and CPUs which have moved 3154 * task running on them. 3155 */ 3156 cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3157 update_closid_rmid(tmpmask, NULL); 3158 3159 closid_free(rdtgrp->closid); 3160 free_rmid(rdtgrp->mon.rmid); 3161 3162 rdtgroup_ctrl_remove(rdtgrp); 3163 3164 /* 3165 * Free all the child monitor group rmids. 3166 */ 3167 free_all_child_rdtgrp(rdtgrp); 3168 3169 return 0; 3170 } 3171 3172 static int rdtgroup_rmdir(struct kernfs_node *kn) 3173 { 3174 struct kernfs_node *parent_kn = kn->parent; 3175 struct rdtgroup *rdtgrp; 3176 cpumask_var_t tmpmask; 3177 int ret = 0; 3178 3179 if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 3180 return -ENOMEM; 3181 3182 rdtgrp = rdtgroup_kn_lock_live(kn); 3183 if (!rdtgrp) { 3184 ret = -EPERM; 3185 goto out; 3186 } 3187 3188 /* 3189 * If the rdtgroup is a ctrl_mon group and parent directory 3190 * is the root directory, remove the ctrl_mon group. 3191 * 3192 * If the rdtgroup is a mon group and parent directory 3193 * is a valid "mon_groups" directory, remove the mon group. 3194 */ 3195 if (rdtgrp->type == RDTCTRL_GROUP && parent_kn == rdtgroup_default.kn && 3196 rdtgrp != &rdtgroup_default) { 3197 if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 3198 rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 3199 ret = rdtgroup_ctrl_remove(rdtgrp); 3200 } else { 3201 ret = rdtgroup_rmdir_ctrl(rdtgrp, tmpmask); 3202 } 3203 } else if (rdtgrp->type == RDTMON_GROUP && 3204 is_mon_groups(parent_kn, kn->name)) { 3205 ret = rdtgroup_rmdir_mon(rdtgrp, tmpmask); 3206 } else { 3207 ret = -EPERM; 3208 } 3209 3210 out: 3211 rdtgroup_kn_unlock(kn); 3212 free_cpumask_var(tmpmask); 3213 return ret; 3214 } 3215 3216 static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf) 3217 { 3218 if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3)) 3219 seq_puts(seq, ",cdp"); 3220 3221 if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) 3222 seq_puts(seq, ",cdpl2"); 3223 3224 if (is_mba_sc(&rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl)) 3225 seq_puts(seq, ",mba_MBps"); 3226 3227 return 0; 3228 } 3229 3230 static struct kernfs_syscall_ops rdtgroup_kf_syscall_ops = { 3231 .mkdir = rdtgroup_mkdir, 3232 .rmdir = rdtgroup_rmdir, 3233 .show_options = rdtgroup_show_options, 3234 }; 3235 3236 static int __init rdtgroup_setup_root(void) 3237 { 3238 int ret; 3239 3240 rdt_root = kernfs_create_root(&rdtgroup_kf_syscall_ops, 3241 KERNFS_ROOT_CREATE_DEACTIVATED | 3242 KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK, 3243 &rdtgroup_default); 3244 if (IS_ERR(rdt_root)) 3245 return PTR_ERR(rdt_root); 3246 3247 mutex_lock(&rdtgroup_mutex); 3248 3249 rdtgroup_default.closid = 0; 3250 rdtgroup_default.mon.rmid = 0; 3251 rdtgroup_default.type = RDTCTRL_GROUP; 3252 INIT_LIST_HEAD(&rdtgroup_default.mon.crdtgrp_list); 3253 3254 list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups); 3255 3256 ret = rdtgroup_add_files(kernfs_root_to_node(rdt_root), RF_CTRL_BASE); 3257 if (ret) { 3258 kernfs_destroy_root(rdt_root); 3259 goto out; 3260 } 3261 3262 rdtgroup_default.kn = kernfs_root_to_node(rdt_root); 3263 kernfs_activate(rdtgroup_default.kn); 3264 3265 out: 3266 mutex_unlock(&rdtgroup_mutex); 3267 3268 return ret; 3269 } 3270 3271 static void domain_destroy_mon_state(struct rdt_domain *d) 3272 { 3273 bitmap_free(d->rmid_busy_llc); 3274 kfree(d->mbm_total); 3275 kfree(d->mbm_local); 3276 } 3277 3278 void resctrl_offline_domain(struct rdt_resource *r, struct rdt_domain *d) 3279 { 3280 lockdep_assert_held(&rdtgroup_mutex); 3281 3282 if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) 3283 mba_sc_domain_destroy(r, d); 3284 3285 if (!r->mon_capable) 3286 return; 3287 3288 /* 3289 * If resctrl is mounted, remove all the 3290 * per domain monitor data directories. 3291 */ 3292 if (static_branch_unlikely(&rdt_mon_enable_key)) 3293 rmdir_mondata_subdir_allrdtgrp(r, d->id); 3294 3295 if (is_mbm_enabled()) 3296 cancel_delayed_work(&d->mbm_over); 3297 if (is_llc_occupancy_enabled() && has_busy_rmid(r, d)) { 3298 /* 3299 * When a package is going down, forcefully 3300 * decrement rmid->ebusy. There is no way to know 3301 * that the L3 was flushed and hence may lead to 3302 * incorrect counts in rare scenarios, but leaving 3303 * the RMID as busy creates RMID leaks if the 3304 * package never comes back. 3305 */ 3306 __check_limbo(d, true); 3307 cancel_delayed_work(&d->cqm_limbo); 3308 } 3309 3310 domain_destroy_mon_state(d); 3311 } 3312 3313 static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_domain *d) 3314 { 3315 size_t tsize; 3316 3317 if (is_llc_occupancy_enabled()) { 3318 d->rmid_busy_llc = bitmap_zalloc(r->num_rmid, GFP_KERNEL); 3319 if (!d->rmid_busy_llc) 3320 return -ENOMEM; 3321 } 3322 if (is_mbm_total_enabled()) { 3323 tsize = sizeof(*d->mbm_total); 3324 d->mbm_total = kcalloc(r->num_rmid, tsize, GFP_KERNEL); 3325 if (!d->mbm_total) { 3326 bitmap_free(d->rmid_busy_llc); 3327 return -ENOMEM; 3328 } 3329 } 3330 if (is_mbm_local_enabled()) { 3331 tsize = sizeof(*d->mbm_local); 3332 d->mbm_local = kcalloc(r->num_rmid, tsize, GFP_KERNEL); 3333 if (!d->mbm_local) { 3334 bitmap_free(d->rmid_busy_llc); 3335 kfree(d->mbm_total); 3336 return -ENOMEM; 3337 } 3338 } 3339 3340 return 0; 3341 } 3342 3343 int resctrl_online_domain(struct rdt_resource *r, struct rdt_domain *d) 3344 { 3345 int err; 3346 3347 lockdep_assert_held(&rdtgroup_mutex); 3348 3349 if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) 3350 /* RDT_RESOURCE_MBA is never mon_capable */ 3351 return mba_sc_domain_allocate(r, d); 3352 3353 if (!r->mon_capable) 3354 return 0; 3355 3356 err = domain_setup_mon_state(r, d); 3357 if (err) 3358 return err; 3359 3360 if (is_mbm_enabled()) { 3361 INIT_DELAYED_WORK(&d->mbm_over, mbm_handle_overflow); 3362 mbm_setup_overflow_handler(d, MBM_OVERFLOW_INTERVAL); 3363 } 3364 3365 if (is_llc_occupancy_enabled()) 3366 INIT_DELAYED_WORK(&d->cqm_limbo, cqm_handle_limbo); 3367 3368 /* If resctrl is mounted, add per domain monitor data directories. */ 3369 if (static_branch_unlikely(&rdt_mon_enable_key)) 3370 mkdir_mondata_subdir_allrdtgrp(r, d); 3371 3372 return 0; 3373 } 3374 3375 /* 3376 * rdtgroup_init - rdtgroup initialization 3377 * 3378 * Setup resctrl file system including set up root, create mount point, 3379 * register rdtgroup filesystem, and initialize files under root directory. 3380 * 3381 * Return: 0 on success or -errno 3382 */ 3383 int __init rdtgroup_init(void) 3384 { 3385 int ret = 0; 3386 3387 seq_buf_init(&last_cmd_status, last_cmd_status_buf, 3388 sizeof(last_cmd_status_buf)); 3389 3390 ret = rdtgroup_setup_root(); 3391 if (ret) 3392 return ret; 3393 3394 ret = sysfs_create_mount_point(fs_kobj, "resctrl"); 3395 if (ret) 3396 goto cleanup_root; 3397 3398 ret = register_filesystem(&rdt_fs_type); 3399 if (ret) 3400 goto cleanup_mountpoint; 3401 3402 /* 3403 * Adding the resctrl debugfs directory here may not be ideal since 3404 * it would let the resctrl debugfs directory appear on the debugfs 3405 * filesystem before the resctrl filesystem is mounted. 3406 * It may also be ok since that would enable debugging of RDT before 3407 * resctrl is mounted. 3408 * The reason why the debugfs directory is created here and not in 3409 * rdt_get_tree() is because rdt_get_tree() takes rdtgroup_mutex and 3410 * during the debugfs directory creation also &sb->s_type->i_mutex_key 3411 * (the lockdep class of inode->i_rwsem). Other filesystem 3412 * interactions (eg. SyS_getdents) have the lock ordering: 3413 * &sb->s_type->i_mutex_key --> &mm->mmap_lock 3414 * During mmap(), called with &mm->mmap_lock, the rdtgroup_mutex 3415 * is taken, thus creating dependency: 3416 * &mm->mmap_lock --> rdtgroup_mutex for the latter that can cause 3417 * issues considering the other two lock dependencies. 3418 * By creating the debugfs directory here we avoid a dependency 3419 * that may cause deadlock (even though file operations cannot 3420 * occur until the filesystem is mounted, but I do not know how to 3421 * tell lockdep that). 3422 */ 3423 debugfs_resctrl = debugfs_create_dir("resctrl", NULL); 3424 3425 return 0; 3426 3427 cleanup_mountpoint: 3428 sysfs_remove_mount_point(fs_kobj, "resctrl"); 3429 cleanup_root: 3430 kernfs_destroy_root(rdt_root); 3431 3432 return ret; 3433 } 3434 3435 void __exit rdtgroup_exit(void) 3436 { 3437 debugfs_remove_recursive(debugfs_resctrl); 3438 unregister_filesystem(&rdt_fs_type); 3439 sysfs_remove_mount_point(fs_kobj, "resctrl"); 3440 kernfs_destroy_root(rdt_root); 3441 } 3442