arch/x86/kernel/cpu/intel_rdt_rdtgroup.c

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