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/cpu.h>
  24 #include <linux/fs.h>
  25 #include <linux/sysfs.h>
  26 #include <linux/kernfs.h>
  27 #include <linux/seq_file.h>
  28 #include <linux/sched/signal.h>
  29 #include <linux/sched/task.h>
  30 #include <linux/slab.h>
  31 #include <linux/task_work.h>
  32
  33 #include <uapi/linux/magic.h>
  34
  35 #include <asm/intel_rdt.h>
  36 #include <asm/intel_rdt_common.h>
  37
  38 DEFINE_STATIC_KEY_FALSE(rdt_enable_key);
  39 struct kernfs_root *rdt_root;
  40 struct rdtgroup rdtgroup_default;
  41 LIST_HEAD(rdt_all_groups);
  42
  43 /* Kernel fs node for "info" directory under root */
  44 static struct kernfs_node *kn_info;
  45
  46 /*
  47  * Trivial allocator for CLOSIDs. Since h/w only supports a small number,
  48  * we can keep a bitmap of free CLOSIDs in a single integer.
  49  *
  50  * Using a global CLOSID across all resources has some advantages and
  51  * some drawbacks:
  52  * + We can simply set "current->closid" to assign a task to a resource
  53  *   group.
  54  * + Context switch code can avoid extra memory references deciding which
  55  *   CLOSID to load into the PQR_ASSOC MSR
  56  * - We give up some options in configuring resource groups across multi-socket
  57  *   systems.
  58  * - Our choices on how to configure each resource become progressively more
  59  *   limited as the number of resources grows.
  60  */
  61 static int closid_free_map;
  62
  63 static void closid_init(void)
  64 {
  65         struct rdt_resource *r;
  66         int rdt_min_closid = 32;
  67
  68         /* Compute rdt_min_closid across all resources */
  69         for_each_enabled_rdt_resource(r)
  70                 rdt_min_closid = min(rdt_min_closid, r->num_closid);
  71
  72         closid_free_map = BIT_MASK(rdt_min_closid) - 1;
  73
  74         /* CLOSID 0 is always reserved for the default group */
  75         closid_free_map &= ~1;
  76 }
  77
  78 int closid_alloc(void)
  79 {
  80         int closid = ffs(closid_free_map);
  81
  82         if (closid == 0)
  83                 return -ENOSPC;
  84         closid--;
  85         closid_free_map &= ~(1 << closid);
  86
  87         return closid;
  88 }
  89
  90 static void closid_free(int closid)
  91 {
  92         closid_free_map |= 1 << closid;
  93 }
  94
  95 /* set uid and gid of rdtgroup dirs and files to that of the creator */
  96 static int rdtgroup_kn_set_ugid(struct kernfs_node *kn)
  97 {
  98         struct iattr iattr = { .ia_valid = ATTR_UID | ATTR_GID,
  99                                 .ia_uid = current_fsuid(),
 100                                 .ia_gid = current_fsgid(), };
 101
 102         if (uid_eq(iattr.ia_uid, GLOBAL_ROOT_UID) &&
 103             gid_eq(iattr.ia_gid, GLOBAL_ROOT_GID))
 104                 return 0;
 105
 106         return kernfs_setattr(kn, &iattr);
 107 }
 108
 109 static int rdtgroup_add_file(struct kernfs_node *parent_kn, struct rftype *rft)
 110 {
 111         struct kernfs_node *kn;
 112         int ret;
 113
 114         kn = __kernfs_create_file(parent_kn, rft->name, rft->mode,
 115                                   0, rft->kf_ops, rft, NULL, NULL);
 116         if (IS_ERR(kn))
 117                 return PTR_ERR(kn);
 118
 119         ret = rdtgroup_kn_set_ugid(kn);
 120         if (ret) {
 121                 kernfs_remove(kn);
 122                 return ret;
 123         }
 124
 125         return 0;
 126 }
 127
 128 static int rdtgroup_add_files(struct kernfs_node *kn, struct rftype *rfts,
 129                               int len)
 130 {
 131         struct rftype *rft;
 132         int ret;
 133
 134         lockdep_assert_held(&rdtgroup_mutex);
 135
 136         for (rft = rfts; rft < rfts + len; rft++) {
 137                 ret = rdtgroup_add_file(kn, rft);
 138                 if (ret)
 139                         goto error;
 140         }
 141
 142         return 0;
 143 error:
 144         pr_warn("Failed to add %s, err=%d\n", rft->name, ret);
 145         while (--rft >= rfts)
 146                 kernfs_remove_by_name(kn, rft->name);
 147         return ret;
 148 }
 149
 150 static int rdtgroup_seqfile_show(struct seq_file *m, void *arg)
 151 {
 152         struct kernfs_open_file *of = m->private;
 153         struct rftype *rft = of->kn->priv;
 154
 155         if (rft->seq_show)
 156                 return rft->seq_show(of, m, arg);
 157         return 0;
 158 }
 159
 160 static ssize_t rdtgroup_file_write(struct kernfs_open_file *of, char *buf,
 161                                    size_t nbytes, loff_t off)
 162 {
 163         struct rftype *rft = of->kn->priv;
 164
 165         if (rft->write)
 166                 return rft->write(of, buf, nbytes, off);
 167
 168         return -EINVAL;
 169 }
 170
 171 static struct kernfs_ops rdtgroup_kf_single_ops = {
 172         .atomic_write_len       = PAGE_SIZE,
 173         .write                  = rdtgroup_file_write,
 174         .seq_show               = rdtgroup_seqfile_show,
 175 };
 176
 177 static int rdtgroup_cpus_show(struct kernfs_open_file *of,
 178                               struct seq_file *s, void *v)
 179 {
 180         struct rdtgroup *rdtgrp;
 181         int ret = 0;
 182
 183         rdtgrp = rdtgroup_kn_lock_live(of->kn);
 184
 185         if (rdtgrp)
 186                 seq_printf(s, "%*pb\n", cpumask_pr_args(&rdtgrp->cpu_mask));
 187         else
 188                 ret = -ENOENT;
 189         rdtgroup_kn_unlock(of->kn);
 190
 191         return ret;
 192 }
 193
 194 /*
 195  * This is safe against intel_rdt_sched_in() called from __switch_to()
 196  * because __switch_to() is executed with interrupts disabled. A local call
 197  * from rdt_update_closid() is proteced against __switch_to() because
 198  * preemption is disabled.
 199  */
 200 static void rdt_update_cpu_closid(void *closid)
 201 {
 202         if (closid)
 203                 this_cpu_write(cpu_closid, *(int *)closid);
 204         /*
 205          * We cannot unconditionally write the MSR because the current
 206          * executing task might have its own closid selected. Just reuse
 207          * the context switch code.
 208          */
 209         intel_rdt_sched_in();
 210 }
 211
 212 /*
 213  * Update the PGR_ASSOC MSR on all cpus in @cpu_mask,
 214  *
 215  * Per task closids must have been set up before calling this function.
 216  *
 217  * The per cpu closids are updated with the smp function call, when @closid
 218  * is not NULL. If @closid is NULL then all affected percpu closids must
 219  * have been set up before calling this function.
 220  */
 221 static void
 222 rdt_update_closid(const struct cpumask *cpu_mask, int *closid)
 223 {
 224         int cpu = get_cpu();
 225
 226         if (cpumask_test_cpu(cpu, cpu_mask))
 227                 rdt_update_cpu_closid(closid);
 228         smp_call_function_many(cpu_mask, rdt_update_cpu_closid, closid, 1);
 229         put_cpu();
 230 }
 231
 232 static ssize_t rdtgroup_cpus_write(struct kernfs_open_file *of,
 233                                    char *buf, size_t nbytes, loff_t off)
 234 {
 235         cpumask_var_t tmpmask, newmask;
 236         struct rdtgroup *rdtgrp, *r;
 237         int ret;
 238
 239         if (!buf)
 240                 return -EINVAL;
 241
 242         if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL))
 243                 return -ENOMEM;
 244         if (!zalloc_cpumask_var(&newmask, GFP_KERNEL)) {
 245                 free_cpumask_var(tmpmask);
 246                 return -ENOMEM;
 247         }
 248
 249         rdtgrp = rdtgroup_kn_lock_live(of->kn);
 250         if (!rdtgrp) {
 251                 ret = -ENOENT;
 252                 goto unlock;
 253         }
 254
 255         ret = cpumask_parse(buf, newmask);
 256         if (ret)
 257                 goto unlock;
 258
 259         /* check that user didn't specify any offline cpus */
 260         cpumask_andnot(tmpmask, newmask, cpu_online_mask);
 261         if (cpumask_weight(tmpmask)) {
 262                 ret = -EINVAL;
 263                 goto unlock;
 264         }
 265
 266         /* Check whether cpus are dropped from this group */
 267         cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask);
 268         if (cpumask_weight(tmpmask)) {
 269                 /* Can't drop from default group */
 270                 if (rdtgrp == &rdtgroup_default) {
 271                         ret = -EINVAL;
 272                         goto unlock;
 273                 }
 274                 /* Give any dropped cpus to rdtgroup_default */
 275                 cpumask_or(&rdtgroup_default.cpu_mask,
 276                            &rdtgroup_default.cpu_mask, tmpmask);
 277                 rdt_update_closid(tmpmask, &rdtgroup_default.closid);
 278         }
 279
 280         /*
 281          * If we added cpus, remove them from previous group that owned them
 282          * and update per-cpu closid
 283          */
 284         cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask);
 285         if (cpumask_weight(tmpmask)) {
 286                 list_for_each_entry(r, &rdt_all_groups, rdtgroup_list) {
 287                         if (r == rdtgrp)
 288                                 continue;
 289                         cpumask_andnot(&r->cpu_mask, &r->cpu_mask, tmpmask);
 290                 }
 291                 rdt_update_closid(tmpmask, &rdtgrp->closid);
 292         }
 293
 294         /* Done pushing/pulling - update this group with new mask */
 295         cpumask_copy(&rdtgrp->cpu_mask, newmask);
 296
 297 unlock:
 298         rdtgroup_kn_unlock(of->kn);
 299         free_cpumask_var(tmpmask);
 300         free_cpumask_var(newmask);
 301
 302         return ret ?: nbytes;
 303 }
 304
 305 struct task_move_callback {
 306         struct callback_head    work;
 307         struct rdtgroup         *rdtgrp;
 308 };
 309
 310 static void move_myself(struct callback_head *head)
 311 {
 312         struct task_move_callback *callback;
 313         struct rdtgroup *rdtgrp;
 314
 315         callback = container_of(head, struct task_move_callback, work);
 316         rdtgrp = callback->rdtgrp;
 317
 318         /*
 319          * If resource group was deleted before this task work callback
 320          * was invoked, then assign the task to root group and free the
 321          * resource group.
 322          */
 323         if (atomic_dec_and_test(&rdtgrp->waitcount) &&
 324             (rdtgrp->flags & RDT_DELETED)) {
 325                 current->closid = 0;
 326                 kfree(rdtgrp);
 327         }
 328
 329         preempt_disable();
 330         /* update PQR_ASSOC MSR to make resource group go into effect */
 331         intel_rdt_sched_in();
 332         preempt_enable();
 333
 334         kfree(callback);
 335 }
 336
 337 static int __rdtgroup_move_task(struct task_struct *tsk,
 338                                 struct rdtgroup *rdtgrp)
 339 {
 340         struct task_move_callback *callback;
 341         int ret;
 342
 343         callback = kzalloc(sizeof(*callback), GFP_KERNEL);
 344         if (!callback)
 345                 return -ENOMEM;
 346         callback->work.func = move_myself;
 347         callback->rdtgrp = rdtgrp;
 348
 349         /*
 350          * Take a refcount, so rdtgrp cannot be freed before the
 351          * callback has been invoked.
 352          */
 353         atomic_inc(&rdtgrp->waitcount);
 354         ret = task_work_add(tsk, &callback->work, true);
 355         if (ret) {
 356                 /*
 357                  * Task is exiting. Drop the refcount and free the callback.
 358                  * No need to check the refcount as the group cannot be
 359                  * deleted before the write function unlocks rdtgroup_mutex.
 360                  */
 361                 atomic_dec(&rdtgrp->waitcount);
 362                 kfree(callback);
 363         } else {
 364                 tsk->closid = rdtgrp->closid;
 365         }
 366         return ret;
 367 }
 368
 369 static int rdtgroup_task_write_permission(struct task_struct *task,
 370                                           struct kernfs_open_file *of)
 371 {
 372         const struct cred *tcred = get_task_cred(task);
 373         const struct cred *cred = current_cred();
 374         int ret = 0;
 375
 376         /*
 377          * Even if we're attaching all tasks in the thread group, we only
 378          * need to check permissions on one of them.
 379          */
 380         if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) &&
 381             !uid_eq(cred->euid, tcred->uid) &&
 382             !uid_eq(cred->euid, tcred->suid))
 383                 ret = -EPERM;
 384
 385         put_cred(tcred);
 386         return ret;
 387 }
 388
 389 static int rdtgroup_move_task(pid_t pid, struct rdtgroup *rdtgrp,
 390                               struct kernfs_open_file *of)
 391 {
 392         struct task_struct *tsk;
 393         int ret;
 394
 395         rcu_read_lock();
 396         if (pid) {
 397                 tsk = find_task_by_vpid(pid);
 398                 if (!tsk) {
 399                         rcu_read_unlock();
 400                         return -ESRCH;
 401                 }
 402         } else {
 403                 tsk = current;
 404         }
 405
 406         get_task_struct(tsk);
 407         rcu_read_unlock();
 408
 409         ret = rdtgroup_task_write_permission(tsk, of);
 410         if (!ret)
 411                 ret = __rdtgroup_move_task(tsk, rdtgrp);
 412
 413         put_task_struct(tsk);
 414         return ret;
 415 }
 416
 417 static ssize_t rdtgroup_tasks_write(struct kernfs_open_file *of,
 418                                     char *buf, size_t nbytes, loff_t off)
 419 {
 420         struct rdtgroup *rdtgrp;
 421         int ret = 0;
 422         pid_t pid;
 423
 424         if (kstrtoint(strstrip(buf), 0, &pid) || pid < 0)
 425                 return -EINVAL;
 426         rdtgrp = rdtgroup_kn_lock_live(of->kn);
 427
 428         if (rdtgrp)
 429                 ret = rdtgroup_move_task(pid, rdtgrp, of);
 430         else
 431                 ret = -ENOENT;
 432
 433         rdtgroup_kn_unlock(of->kn);
 434
 435         return ret ?: nbytes;
 436 }
 437
 438 static void show_rdt_tasks(struct rdtgroup *r, struct seq_file *s)
 439 {
 440         struct task_struct *p, *t;
 441
 442         rcu_read_lock();
 443         for_each_process_thread(p, t) {
 444                 if (t->closid == r->closid)
 445                         seq_printf(s, "%d\n", t->pid);
 446         }
 447         rcu_read_unlock();
 448 }
 449
 450 static int rdtgroup_tasks_show(struct kernfs_open_file *of,
 451                                struct seq_file *s, void *v)
 452 {
 453         struct rdtgroup *rdtgrp;
 454         int ret = 0;
 455
 456         rdtgrp = rdtgroup_kn_lock_live(of->kn);
 457         if (rdtgrp)
 458                 show_rdt_tasks(rdtgrp, s);
 459         else
 460                 ret = -ENOENT;
 461         rdtgroup_kn_unlock(of->kn);
 462
 463         return ret;
 464 }
 465
 466 /* Files in each rdtgroup */
 467 static struct rftype rdtgroup_base_files[] = {
 468         {
 469                 .name           = "cpus",
 470                 .mode           = 0644,
 471                 .kf_ops         = &rdtgroup_kf_single_ops,
 472                 .write          = rdtgroup_cpus_write,
 473                 .seq_show       = rdtgroup_cpus_show,
 474         },
 475         {
 476                 .name           = "tasks",
 477                 .mode           = 0644,
 478                 .kf_ops         = &rdtgroup_kf_single_ops,
 479                 .write          = rdtgroup_tasks_write,
 480                 .seq_show       = rdtgroup_tasks_show,
 481         },
 482         {
 483                 .name           = "schemata",
 484                 .mode           = 0644,
 485                 .kf_ops         = &rdtgroup_kf_single_ops,
 486                 .write          = rdtgroup_schemata_write,
 487                 .seq_show       = rdtgroup_schemata_show,
 488         },
 489 };
 490
 491 static int rdt_num_closids_show(struct kernfs_open_file *of,
 492                                 struct seq_file *seq, void *v)
 493 {
 494         struct rdt_resource *r = of->kn->parent->priv;
 495
 496         seq_printf(seq, "%d\n", r->num_closid);
 497
 498         return 0;
 499 }
 500
 501 static int rdt_cbm_mask_show(struct kernfs_open_file *of,
 502                              struct seq_file *seq, void *v)
 503 {
 504         struct rdt_resource *r = of->kn->parent->priv;
 505
 506         seq_printf(seq, "%x\n", r->max_cbm);
 507
 508         return 0;
 509 }
 510
 511 static int rdt_min_cbm_bits_show(struct kernfs_open_file *of,
 512                              struct seq_file *seq, void *v)
 513 {
 514         struct rdt_resource *r = of->kn->parent->priv;
 515
 516         seq_printf(seq, "%d\n", r->min_cbm_bits);
 517
 518         return 0;
 519 }
 520
 521 /* rdtgroup information files for one cache resource. */
 522 static struct rftype res_info_files[] = {
 523         {
 524                 .name           = "num_closids",
 525                 .mode           = 0444,
 526                 .kf_ops         = &rdtgroup_kf_single_ops,
 527                 .seq_show       = rdt_num_closids_show,
 528         },
 529         {
 530                 .name           = "cbm_mask",
 531                 .mode           = 0444,
 532                 .kf_ops         = &rdtgroup_kf_single_ops,
 533                 .seq_show       = rdt_cbm_mask_show,
 534         },
 535         {
 536                 .name           = "min_cbm_bits",
 537                 .mode           = 0444,
 538                 .kf_ops         = &rdtgroup_kf_single_ops,
 539                 .seq_show       = rdt_min_cbm_bits_show,
 540         },
 541 };
 542
 543 static int rdtgroup_create_info_dir(struct kernfs_node *parent_kn)
 544 {
 545         struct kernfs_node *kn_subdir;
 546         struct rdt_resource *r;
 547         int ret;
 548
 549         /* create the directory */
 550         kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL);
 551         if (IS_ERR(kn_info))
 552                 return PTR_ERR(kn_info);
 553         kernfs_get(kn_info);
 554
 555         for_each_enabled_rdt_resource(r) {
 556                 kn_subdir = kernfs_create_dir(kn_info, r->name,
 557                                               kn_info->mode, r);
 558                 if (IS_ERR(kn_subdir)) {
 559                         ret = PTR_ERR(kn_subdir);
 560                         goto out_destroy;
 561                 }
 562                 kernfs_get(kn_subdir);
 563                 ret = rdtgroup_kn_set_ugid(kn_subdir);
 564                 if (ret)
 565                         goto out_destroy;
 566                 ret = rdtgroup_add_files(kn_subdir, res_info_files,
 567                                          ARRAY_SIZE(res_info_files));
 568                 if (ret)
 569                         goto out_destroy;
 570                 kernfs_activate(kn_subdir);
 571         }
 572
 573         /*
 574          * This extra ref will be put in kernfs_remove() and guarantees
 575          * that @rdtgrp->kn is always accessible.
 576          */
 577         kernfs_get(kn_info);
 578
 579         ret = rdtgroup_kn_set_ugid(kn_info);
 580         if (ret)
 581                 goto out_destroy;
 582
 583         kernfs_activate(kn_info);
 584
 585         return 0;
 586
 587 out_destroy:
 588         kernfs_remove(kn_info);
 589         return ret;
 590 }
 591
 592 static void l3_qos_cfg_update(void *arg)
 593 {
 594         bool *enable = arg;
 595
 596         wrmsrl(IA32_L3_QOS_CFG, *enable ? L3_QOS_CDP_ENABLE : 0ULL);
 597 }
 598
 599 static int set_l3_qos_cfg(struct rdt_resource *r, bool enable)
 600 {
 601         cpumask_var_t cpu_mask;
 602         struct rdt_domain *d;
 603         int cpu;
 604
 605         if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
 606                 return -ENOMEM;
 607
 608         list_for_each_entry(d, &r->domains, list) {
 609                 /* Pick one CPU from each domain instance to update MSR */
 610                 cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask);
 611         }
 612         cpu = get_cpu();
 613         /* Update QOS_CFG MSR on this cpu if it's in cpu_mask. */
 614         if (cpumask_test_cpu(cpu, cpu_mask))
 615                 l3_qos_cfg_update(&enable);
 616         /* Update QOS_CFG MSR on all other cpus in cpu_mask. */
 617         smp_call_function_many(cpu_mask, l3_qos_cfg_update, &enable, 1);
 618         put_cpu();
 619
 620         free_cpumask_var(cpu_mask);
 621
 622         return 0;
 623 }
 624
 625 static int cdp_enable(void)
 626 {
 627         struct rdt_resource *r_l3data = &rdt_resources_all[RDT_RESOURCE_L3DATA];
 628         struct rdt_resource *r_l3code = &rdt_resources_all[RDT_RESOURCE_L3CODE];
 629         struct rdt_resource *r_l3 = &rdt_resources_all[RDT_RESOURCE_L3];
 630         int ret;
 631
 632         if (!r_l3->capable || !r_l3data->capable || !r_l3code->capable)
 633                 return -EINVAL;
 634
 635         ret = set_l3_qos_cfg(r_l3, true);
 636         if (!ret) {
 637                 r_l3->enabled = false;
 638                 r_l3data->enabled = true;
 639                 r_l3code->enabled = true;
 640         }
 641         return ret;
 642 }
 643
 644 static void cdp_disable(void)
 645 {
 646         struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_L3];
 647
 648         r->enabled = r->capable;
 649
 650         if (rdt_resources_all[RDT_RESOURCE_L3DATA].enabled) {
 651                 rdt_resources_all[RDT_RESOURCE_L3DATA].enabled = false;
 652                 rdt_resources_all[RDT_RESOURCE_L3CODE].enabled = false;
 653                 set_l3_qos_cfg(r, false);
 654         }
 655 }
 656
 657 static int parse_rdtgroupfs_options(char *data)
 658 {
 659         char *token, *o = data;
 660         int ret = 0;
 661
 662         while ((token = strsep(&o, ",")) != NULL) {
 663                 if (!*token)
 664                         return -EINVAL;
 665
 666                 if (!strcmp(token, "cdp"))
 667                         ret = cdp_enable();
 668         }
 669
 670         return ret;
 671 }
 672
 673 /*
 674  * We don't allow rdtgroup directories to be created anywhere
 675  * except the root directory. Thus when looking for the rdtgroup
 676  * structure for a kernfs node we are either looking at a directory,
 677  * in which case the rdtgroup structure is pointed at by the "priv"
 678  * field, otherwise we have a file, and need only look to the parent
 679  * to find the rdtgroup.
 680  */
 681 static struct rdtgroup *kernfs_to_rdtgroup(struct kernfs_node *kn)
 682 {
 683         if (kernfs_type(kn) == KERNFS_DIR) {
 684                 /*
 685                  * All the resource directories use "kn->priv"
 686                  * to point to the "struct rdtgroup" for the
 687                  * resource. "info" and its subdirectories don't
 688                  * have rdtgroup structures, so return NULL here.
 689                  */
 690                 if (kn == kn_info || kn->parent == kn_info)
 691                         return NULL;
 692                 else
 693                         return kn->priv;
 694         } else {
 695                 return kn->parent->priv;
 696         }
 697 }
 698
 699 struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn)
 700 {
 701         struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn);
 702
 703         if (!rdtgrp)
 704                 return NULL;
 705
 706         atomic_inc(&rdtgrp->waitcount);
 707         kernfs_break_active_protection(kn);
 708
 709         mutex_lock(&rdtgroup_mutex);
 710
 711         /* Was this group deleted while we waited? */
 712         if (rdtgrp->flags & RDT_DELETED)
 713                 return NULL;
 714
 715         return rdtgrp;
 716 }
 717
 718 void rdtgroup_kn_unlock(struct kernfs_node *kn)
 719 {
 720         struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn);
 721
 722         if (!rdtgrp)
 723                 return;
 724
 725         mutex_unlock(&rdtgroup_mutex);
 726
 727         if (atomic_dec_and_test(&rdtgrp->waitcount) &&
 728             (rdtgrp->flags & RDT_DELETED)) {
 729                 kernfs_unbreak_active_protection(kn);
 730                 kernfs_put(kn);
 731                 kfree(rdtgrp);
 732         } else {
 733                 kernfs_unbreak_active_protection(kn);
 734         }
 735 }
 736
 737 static struct dentry *rdt_mount(struct file_system_type *fs_type,
 738                                 int flags, const char *unused_dev_name,
 739                                 void *data)
 740 {
 741         struct dentry *dentry;
 742         int ret;
 743
 744         mutex_lock(&rdtgroup_mutex);
 745         /*
 746          * resctrl file system can only be mounted once.
 747          */
 748         if (static_branch_unlikely(&rdt_enable_key)) {
 749                 dentry = ERR_PTR(-EBUSY);
 750                 goto out;
 751         }
 752
 753         ret = parse_rdtgroupfs_options(data);
 754         if (ret) {
 755                 dentry = ERR_PTR(ret);
 756                 goto out_cdp;
 757         }
 758
 759         closid_init();
 760
 761         ret = rdtgroup_create_info_dir(rdtgroup_default.kn);
 762         if (ret) {
 763                 dentry = ERR_PTR(ret);
 764                 goto out_cdp;
 765         }
 766
 767         dentry = kernfs_mount(fs_type, flags, rdt_root,
 768                               RDTGROUP_SUPER_MAGIC, NULL);
 769         if (IS_ERR(dentry))
 770                 goto out_cdp;
 771
 772         static_branch_enable(&rdt_enable_key);
 773         goto out;
 774
 775 out_cdp:
 776         cdp_disable();
 777 out:
 778         mutex_unlock(&rdtgroup_mutex);
 779
 780         return dentry;
 781 }
 782
 783 static int reset_all_cbms(struct rdt_resource *r)
 784 {
 785         struct msr_param msr_param;
 786         cpumask_var_t cpu_mask;
 787         struct rdt_domain *d;
 788         int i, cpu;
 789
 790         if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
 791                 return -ENOMEM;
 792
 793         msr_param.res = r;
 794         msr_param.low = 0;
 795         msr_param.high = r->num_closid;
 796
 797         /*
 798          * Disable resource control for this resource by setting all
 799          * CBMs in all domains to the maximum mask value. Pick one CPU
 800          * from each domain to update the MSRs below.
 801          */
 802         list_for_each_entry(d, &r->domains, list) {
 803                 cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask);
 804
 805                 for (i = 0; i < r->num_closid; i++)
 806                         d->cbm[i] = r->max_cbm;
 807         }
 808         cpu = get_cpu();
 809         /* Update CBM on this cpu if it's in cpu_mask. */
 810         if (cpumask_test_cpu(cpu, cpu_mask))
 811                 rdt_cbm_update(&msr_param);
 812         /* Update CBM on all other cpus in cpu_mask. */
 813         smp_call_function_many(cpu_mask, rdt_cbm_update, &msr_param, 1);
 814         put_cpu();
 815
 816         free_cpumask_var(cpu_mask);
 817
 818         return 0;
 819 }
 820
 821 /*
 822  * Move tasks from one to the other group. If @from is NULL, then all tasks
 823  * in the systems are moved unconditionally (used for teardown).
 824  *
 825  * If @mask is not NULL the cpus on which moved tasks are running are set
 826  * in that mask so the update smp function call is restricted to affected
 827  * cpus.
 828  */
 829 static void rdt_move_group_tasks(struct rdtgroup *from, struct rdtgroup *to,
 830                                  struct cpumask *mask)
 831 {
 832         struct task_struct *p, *t;
 833
 834         read_lock(&tasklist_lock);
 835         for_each_process_thread(p, t) {
 836                 if (!from || t->closid == from->closid) {
 837                         t->closid = to->closid;
 838 #ifdef CONFIG_SMP
 839                         /*
 840                          * This is safe on x86 w/o barriers as the ordering
 841                          * of writing to task_cpu() and t->on_cpu is
 842                          * reverse to the reading here. The detection is
 843                          * inaccurate as tasks might move or schedule
 844                          * before the smp function call takes place. In
 845                          * such a case the function call is pointless, but
 846                          * there is no other side effect.
 847                          */
 848                         if (mask && t->on_cpu)
 849                                 cpumask_set_cpu(task_cpu(t), mask);
 850 #endif
 851                 }
 852         }
 853         read_unlock(&tasklist_lock);
 854 }
 855
 856 /*
 857  * Forcibly remove all of subdirectories under root.
 858  */
 859 static void rmdir_all_sub(void)
 860 {
 861         struct rdtgroup *rdtgrp, *tmp;
 862
 863         /* Move all tasks to the default resource group */
 864         rdt_move_group_tasks(NULL, &rdtgroup_default, NULL);
 865
 866         list_for_each_entry_safe(rdtgrp, tmp, &rdt_all_groups, rdtgroup_list) {
 867                 /* Remove each rdtgroup other than root */
 868                 if (rdtgrp == &rdtgroup_default)
 869                         continue;
 870
 871                 /*
 872                  * Give any CPUs back to the default group. We cannot copy
 873                  * cpu_online_mask because a CPU might have executed the
 874                  * offline callback already, but is still marked online.
 875                  */
 876                 cpumask_or(&rdtgroup_default.cpu_mask,
 877                            &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask);
 878
 879                 kernfs_remove(rdtgrp->kn);
 880                 list_del(&rdtgrp->rdtgroup_list);
 881                 kfree(rdtgrp);
 882         }
 883         /* Notify online CPUs to update per cpu storage and PQR_ASSOC MSR */
 884         get_online_cpus();
 885         rdt_update_closid(cpu_online_mask, &rdtgroup_default.closid);
 886         put_online_cpus();
 887
 888         kernfs_remove(kn_info);
 889 }
 890
 891 static void rdt_kill_sb(struct super_block *sb)
 892 {
 893         struct rdt_resource *r;
 894
 895         mutex_lock(&rdtgroup_mutex);
 896
 897         /*Put everything back to default values. */
 898         for_each_enabled_rdt_resource(r)
 899                 reset_all_cbms(r);
 900         cdp_disable();
 901         rmdir_all_sub();
 902         static_branch_disable(&rdt_enable_key);
 903         kernfs_kill_sb(sb);
 904         mutex_unlock(&rdtgroup_mutex);
 905 }
 906
 907 static struct file_system_type rdt_fs_type = {
 908         .name    = "resctrl",
 909         .mount   = rdt_mount,
 910         .kill_sb = rdt_kill_sb,
 911 };
 912
 913 static int rdtgroup_mkdir(struct kernfs_node *parent_kn, const char *name,
 914                           umode_t mode)
 915 {
 916         struct rdtgroup *parent, *rdtgrp;
 917         struct kernfs_node *kn;
 918         int ret, closid;
 919
 920         /* Only allow mkdir in the root directory */
 921         if (parent_kn != rdtgroup_default.kn)
 922                 return -EPERM;
 923
 924         /* Do not accept '\n' to avoid unparsable situation. */
 925         if (strchr(name, '\n'))
 926                 return -EINVAL;
 927
 928         parent = rdtgroup_kn_lock_live(parent_kn);
 929         if (!parent) {
 930                 ret = -ENODEV;
 931                 goto out_unlock;
 932         }
 933
 934         ret = closid_alloc();
 935         if (ret < 0)
 936                 goto out_unlock;
 937         closid = ret;
 938
 939         /* allocate the rdtgroup. */
 940         rdtgrp = kzalloc(sizeof(*rdtgrp), GFP_KERNEL);
 941         if (!rdtgrp) {
 942                 ret = -ENOSPC;
 943                 goto out_closid_free;
 944         }
 945         rdtgrp->closid = closid;
 946         list_add(&rdtgrp->rdtgroup_list, &rdt_all_groups);
 947
 948         /* kernfs creates the directory for rdtgrp */
 949         kn = kernfs_create_dir(parent->kn, name, mode, rdtgrp);
 950         if (IS_ERR(kn)) {
 951                 ret = PTR_ERR(kn);
 952                 goto out_cancel_ref;
 953         }
 954         rdtgrp->kn = kn;
 955
 956         /*
 957          * kernfs_remove() will drop the reference count on "kn" which
 958          * will free it. But we still need it to stick around for the
 959          * rdtgroup_kn_unlock(kn} call below. Take one extra reference
 960          * here, which will be dropped inside rdtgroup_kn_unlock().
 961          */
 962         kernfs_get(kn);
 963
 964         ret = rdtgroup_kn_set_ugid(kn);
 965         if (ret)
 966                 goto out_destroy;
 967
 968         ret = rdtgroup_add_files(kn, rdtgroup_base_files,
 969                                  ARRAY_SIZE(rdtgroup_base_files));
 970         if (ret)
 971                 goto out_destroy;
 972
 973         kernfs_activate(kn);
 974
 975         ret = 0;
 976         goto out_unlock;
 977
 978 out_destroy:
 979         kernfs_remove(rdtgrp->kn);
 980 out_cancel_ref:
 981         list_del(&rdtgrp->rdtgroup_list);
 982         kfree(rdtgrp);
 983 out_closid_free:
 984         closid_free(closid);
 985 out_unlock:
 986         rdtgroup_kn_unlock(parent_kn);
 987         return ret;
 988 }
 989
 990 static int rdtgroup_rmdir(struct kernfs_node *kn)
 991 {
 992         int ret, cpu, closid = rdtgroup_default.closid;
 993         struct rdtgroup *rdtgrp;
 994         cpumask_var_t tmpmask;
 995
 996         if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL))
 997                 return -ENOMEM;
 998
 999         rdtgrp = rdtgroup_kn_lock_live(kn);
1000         if (!rdtgrp) {
1001                 ret = -EPERM;
1002                 goto out;
1003         }
1004
1005         /* Give any tasks back to the default group */
1006         rdt_move_group_tasks(rdtgrp, &rdtgroup_default, tmpmask);
1007
1008         /* Give any CPUs back to the default group */
1009         cpumask_or(&rdtgroup_default.cpu_mask,
1010                    &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask);
1011
1012         /* Update per cpu closid of the moved CPUs first */
1013         for_each_cpu(cpu, &rdtgrp->cpu_mask)
1014                 per_cpu(cpu_closid, cpu) = closid;
1015         /*
1016          * Update the MSR on moved CPUs and CPUs which have moved
1017          * task running on them.
1018          */
1019         cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask);
1020         rdt_update_closid(tmpmask, NULL);
1021
1022         rdtgrp->flags = RDT_DELETED;
1023         closid_free(rdtgrp->closid);
1024         list_del(&rdtgrp->rdtgroup_list);
1025
1026         /*
1027          * one extra hold on this, will drop when we kfree(rdtgrp)
1028          * in rdtgroup_kn_unlock()
1029          */
1030         kernfs_get(kn);
1031         kernfs_remove(rdtgrp->kn);
1032         ret = 0;
1033 out:
1034         rdtgroup_kn_unlock(kn);
1035         free_cpumask_var(tmpmask);
1036         return ret;
1037 }
1038
1039 static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf)
1040 {
1041         if (rdt_resources_all[RDT_RESOURCE_L3DATA].enabled)
1042                 seq_puts(seq, ",cdp");
1043         return 0;
1044 }
1045
1046 static struct kernfs_syscall_ops rdtgroup_kf_syscall_ops = {
1047         .mkdir          = rdtgroup_mkdir,
1048         .rmdir          = rdtgroup_rmdir,
1049         .show_options   = rdtgroup_show_options,
1050 };
1051
1052 static int __init rdtgroup_setup_root(void)
1053 {
1054         int ret;
1055
1056         rdt_root = kernfs_create_root(&rdtgroup_kf_syscall_ops,
1057                                       KERNFS_ROOT_CREATE_DEACTIVATED,
1058                                       &rdtgroup_default);
1059         if (IS_ERR(rdt_root))
1060                 return PTR_ERR(rdt_root);
1061
1062         mutex_lock(&rdtgroup_mutex);
1063
1064         rdtgroup_default.closid = 0;
1065         list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups);
1066
1067         ret = rdtgroup_add_files(rdt_root->kn, rdtgroup_base_files,
1068                                  ARRAY_SIZE(rdtgroup_base_files));
1069         if (ret) {
1070                 kernfs_destroy_root(rdt_root);
1071                 goto out;
1072         }
1073
1074         rdtgroup_default.kn = rdt_root->kn;
1075         kernfs_activate(rdtgroup_default.kn);
1076
1077 out:
1078         mutex_unlock(&rdtgroup_mutex);
1079
1080         return ret;
1081 }
1082
1083 /*
1084  * rdtgroup_init - rdtgroup initialization
1085  *
1086  * Setup resctrl file system including set up root, create mount point,
1087  * register rdtgroup filesystem, and initialize files under root directory.
1088  *
1089  * Return: 0 on success or -errno
1090  */
1091 int __init rdtgroup_init(void)
1092 {
1093         int ret = 0;
1094
1095         ret = rdtgroup_setup_root();
1096         if (ret)
1097                 return ret;
1098
1099         ret = sysfs_create_mount_point(fs_kobj, "resctrl");
1100         if (ret)
1101                 goto cleanup_root;
1102
1103         ret = register_filesystem(&rdt_fs_type);
1104         if (ret)
1105                 goto cleanup_mountpoint;
1106
1107         return 0;
1108
1109 cleanup_mountpoint:
1110         sysfs_remove_mount_point(fs_kobj, "resctrl");
1111 cleanup_root:
1112         kernfs_destroy_root(rdt_root);
1113
1114         return ret;
1115 }