12025cf9eSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2fa7d9493SBabu Moger /* 3d9f6e12fSIngo Molnar * User interface for Resource Allocation in Resource Director Technology(RDT) 4fa7d9493SBabu Moger * 5fa7d9493SBabu Moger * Copyright (C) 2016 Intel Corporation 6fa7d9493SBabu Moger * 7fa7d9493SBabu Moger * Author: Fenghua Yu <fenghua.yu@intel.com> 8fa7d9493SBabu Moger * 9fa7d9493SBabu Moger * More information about RDT be found in the Intel (R) x86 Architecture 10fa7d9493SBabu Moger * Software Developer Manual. 11fa7d9493SBabu Moger */ 12fa7d9493SBabu Moger 13fa7d9493SBabu Moger #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14fa7d9493SBabu Moger 15fa7d9493SBabu Moger #include <linux/cacheinfo.h> 16fa7d9493SBabu Moger #include <linux/cpu.h> 17fa7d9493SBabu Moger #include <linux/debugfs.h> 18fa7d9493SBabu Moger #include <linux/fs.h> 1923bf1b6bSDavid Howells #include <linux/fs_parser.h> 20fa7d9493SBabu Moger #include <linux/sysfs.h> 21fa7d9493SBabu Moger #include <linux/kernfs.h> 22fa7d9493SBabu Moger #include <linux/seq_buf.h> 23fa7d9493SBabu Moger #include <linux/seq_file.h> 24fa7d9493SBabu Moger #include <linux/sched/signal.h> 25fa7d9493SBabu Moger #include <linux/sched/task.h> 26fa7d9493SBabu Moger #include <linux/slab.h> 27fa7d9493SBabu Moger #include <linux/task_work.h> 2823bf1b6bSDavid Howells #include <linux/user_namespace.h> 29fa7d9493SBabu Moger 30fa7d9493SBabu Moger #include <uapi/linux/magic.h> 31fa7d9493SBabu Moger 328dd97c65SReinette Chatre #include <asm/resctrl.h> 33fa7d9493SBabu Moger #include "internal.h" 34fa7d9493SBabu Moger 35fa7d9493SBabu Moger DEFINE_STATIC_KEY_FALSE(rdt_enable_key); 36fa7d9493SBabu Moger DEFINE_STATIC_KEY_FALSE(rdt_mon_enable_key); 37fa7d9493SBabu Moger DEFINE_STATIC_KEY_FALSE(rdt_alloc_enable_key); 38fa7d9493SBabu Moger static struct kernfs_root *rdt_root; 39fa7d9493SBabu Moger struct rdtgroup rdtgroup_default; 40fa7d9493SBabu Moger LIST_HEAD(rdt_all_groups); 41fa7d9493SBabu Moger 42cdb9ebc9SJames Morse /* list of entries for the schemata file */ 43cdb9ebc9SJames Morse LIST_HEAD(resctrl_schema_all); 44cdb9ebc9SJames Morse 45fa7d9493SBabu Moger /* Kernel fs node for "info" directory under root */ 46fa7d9493SBabu Moger static struct kernfs_node *kn_info; 47fa7d9493SBabu Moger 48fa7d9493SBabu Moger /* Kernel fs node for "mon_groups" directory under root */ 49fa7d9493SBabu Moger static struct kernfs_node *kn_mongrp; 50fa7d9493SBabu Moger 51fa7d9493SBabu Moger /* Kernel fs node for "mon_data" directory under root */ 52fa7d9493SBabu Moger static struct kernfs_node *kn_mondata; 53fa7d9493SBabu Moger 54fa7d9493SBabu Moger static struct seq_buf last_cmd_status; 55fa7d9493SBabu Moger static char last_cmd_status_buf[512]; 56fa7d9493SBabu Moger 57fa7d9493SBabu Moger struct dentry *debugfs_resctrl; 58fa7d9493SBabu Moger 59fa7d9493SBabu Moger void rdt_last_cmd_clear(void) 60fa7d9493SBabu Moger { 61fa7d9493SBabu Moger lockdep_assert_held(&rdtgroup_mutex); 62fa7d9493SBabu Moger seq_buf_clear(&last_cmd_status); 63fa7d9493SBabu Moger } 64fa7d9493SBabu Moger 65fa7d9493SBabu Moger void rdt_last_cmd_puts(const char *s) 66fa7d9493SBabu Moger { 67fa7d9493SBabu Moger lockdep_assert_held(&rdtgroup_mutex); 68fa7d9493SBabu Moger seq_buf_puts(&last_cmd_status, s); 69fa7d9493SBabu Moger } 70fa7d9493SBabu Moger 71fa7d9493SBabu Moger void rdt_last_cmd_printf(const char *fmt, ...) 72fa7d9493SBabu Moger { 73fa7d9493SBabu Moger va_list ap; 74fa7d9493SBabu Moger 75fa7d9493SBabu Moger va_start(ap, fmt); 76fa7d9493SBabu Moger lockdep_assert_held(&rdtgroup_mutex); 77fa7d9493SBabu Moger seq_buf_vprintf(&last_cmd_status, fmt, ap); 78fa7d9493SBabu Moger va_end(ap); 79fa7d9493SBabu Moger } 80fa7d9493SBabu Moger 81*0424a7dfSShawn Wang void rdt_staged_configs_clear(void) 82*0424a7dfSShawn Wang { 83*0424a7dfSShawn Wang struct rdt_resource *r; 84*0424a7dfSShawn Wang struct rdt_domain *dom; 85*0424a7dfSShawn Wang 86*0424a7dfSShawn Wang lockdep_assert_held(&rdtgroup_mutex); 87*0424a7dfSShawn Wang 88*0424a7dfSShawn Wang for_each_alloc_capable_rdt_resource(r) { 89*0424a7dfSShawn Wang list_for_each_entry(dom, &r->domains, list) 90*0424a7dfSShawn Wang memset(dom->staged_config, 0, sizeof(dom->staged_config)); 91*0424a7dfSShawn Wang } 92*0424a7dfSShawn Wang } 93*0424a7dfSShawn Wang 94fa7d9493SBabu Moger /* 95fa7d9493SBabu Moger * Trivial allocator for CLOSIDs. Since h/w only supports a small number, 96fa7d9493SBabu Moger * we can keep a bitmap of free CLOSIDs in a single integer. 97fa7d9493SBabu Moger * 98fa7d9493SBabu Moger * Using a global CLOSID across all resources has some advantages and 99fa7d9493SBabu Moger * some drawbacks: 100fa7d9493SBabu Moger * + We can simply set "current->closid" to assign a task to a resource 101fa7d9493SBabu Moger * group. 102fa7d9493SBabu Moger * + Context switch code can avoid extra memory references deciding which 103fa7d9493SBabu Moger * CLOSID to load into the PQR_ASSOC MSR 104fa7d9493SBabu Moger * - We give up some options in configuring resource groups across multi-socket 105fa7d9493SBabu Moger * systems. 106fa7d9493SBabu Moger * - Our choices on how to configure each resource become progressively more 107fa7d9493SBabu Moger * limited as the number of resources grows. 108fa7d9493SBabu Moger */ 109fa7d9493SBabu Moger static int closid_free_map; 110fa7d9493SBabu Moger static int closid_free_map_len; 111fa7d9493SBabu Moger 112fa7d9493SBabu Moger int closids_supported(void) 113fa7d9493SBabu Moger { 114fa7d9493SBabu Moger return closid_free_map_len; 115fa7d9493SBabu Moger } 116fa7d9493SBabu Moger 117fa7d9493SBabu Moger static void closid_init(void) 118fa7d9493SBabu Moger { 119331ebe4cSJames Morse struct resctrl_schema *s; 120eb6f3187SJames Morse u32 rdt_min_closid = 32; 121fa7d9493SBabu Moger 122fa7d9493SBabu Moger /* Compute rdt_min_closid across all resources */ 1233183e87cSJames Morse list_for_each_entry(s, &resctrl_schema_all, list) 1243183e87cSJames Morse rdt_min_closid = min(rdt_min_closid, s->num_closid); 125fa7d9493SBabu Moger 126fa7d9493SBabu Moger closid_free_map = BIT_MASK(rdt_min_closid) - 1; 127fa7d9493SBabu Moger 128fa7d9493SBabu Moger /* CLOSID 0 is always reserved for the default group */ 129fa7d9493SBabu Moger closid_free_map &= ~1; 130fa7d9493SBabu Moger closid_free_map_len = rdt_min_closid; 131fa7d9493SBabu Moger } 132fa7d9493SBabu Moger 133fa7d9493SBabu Moger static int closid_alloc(void) 134fa7d9493SBabu Moger { 135fa7d9493SBabu Moger u32 closid = ffs(closid_free_map); 136fa7d9493SBabu Moger 137fa7d9493SBabu Moger if (closid == 0) 138fa7d9493SBabu Moger return -ENOSPC; 139fa7d9493SBabu Moger closid--; 140fa7d9493SBabu Moger closid_free_map &= ~(1 << closid); 141fa7d9493SBabu Moger 142fa7d9493SBabu Moger return closid; 143fa7d9493SBabu Moger } 144fa7d9493SBabu Moger 145fa7d9493SBabu Moger void closid_free(int closid) 146fa7d9493SBabu Moger { 147fa7d9493SBabu Moger closid_free_map |= 1 << closid; 148fa7d9493SBabu Moger } 149fa7d9493SBabu Moger 150fa7d9493SBabu Moger /** 151fa7d9493SBabu Moger * closid_allocated - test if provided closid is in use 152fa7d9493SBabu Moger * @closid: closid to be tested 153fa7d9493SBabu Moger * 154fa7d9493SBabu Moger * Return: true if @closid is currently associated with a resource group, 155fa7d9493SBabu Moger * false if @closid is free 156fa7d9493SBabu Moger */ 157fa7d9493SBabu Moger static bool closid_allocated(unsigned int closid) 158fa7d9493SBabu Moger { 159fa7d9493SBabu Moger return (closid_free_map & (1 << closid)) == 0; 160fa7d9493SBabu Moger } 161fa7d9493SBabu Moger 162fa7d9493SBabu Moger /** 163fa7d9493SBabu Moger * rdtgroup_mode_by_closid - Return mode of resource group with closid 164fa7d9493SBabu Moger * @closid: closid if the resource group 165fa7d9493SBabu Moger * 166fa7d9493SBabu Moger * Each resource group is associated with a @closid. Here the mode 167fa7d9493SBabu Moger * of a resource group can be queried by searching for it using its closid. 168fa7d9493SBabu Moger * 169fa7d9493SBabu Moger * Return: mode as &enum rdtgrp_mode of resource group with closid @closid 170fa7d9493SBabu Moger */ 171fa7d9493SBabu Moger enum rdtgrp_mode rdtgroup_mode_by_closid(int closid) 172fa7d9493SBabu Moger { 173fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 174fa7d9493SBabu Moger 175fa7d9493SBabu Moger list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 176fa7d9493SBabu Moger if (rdtgrp->closid == closid) 177fa7d9493SBabu Moger return rdtgrp->mode; 178fa7d9493SBabu Moger } 179fa7d9493SBabu Moger 180fa7d9493SBabu Moger return RDT_NUM_MODES; 181fa7d9493SBabu Moger } 182fa7d9493SBabu Moger 183fa7d9493SBabu Moger static const char * const rdt_mode_str[] = { 184fa7d9493SBabu Moger [RDT_MODE_SHAREABLE] = "shareable", 185fa7d9493SBabu Moger [RDT_MODE_EXCLUSIVE] = "exclusive", 186fa7d9493SBabu Moger [RDT_MODE_PSEUDO_LOCKSETUP] = "pseudo-locksetup", 187fa7d9493SBabu Moger [RDT_MODE_PSEUDO_LOCKED] = "pseudo-locked", 188fa7d9493SBabu Moger }; 189fa7d9493SBabu Moger 190fa7d9493SBabu Moger /** 191fa7d9493SBabu Moger * rdtgroup_mode_str - Return the string representation of mode 192fa7d9493SBabu Moger * @mode: the resource group mode as &enum rdtgroup_mode 193fa7d9493SBabu Moger * 194fa7d9493SBabu Moger * Return: string representation of valid mode, "unknown" otherwise 195fa7d9493SBabu Moger */ 196fa7d9493SBabu Moger static const char *rdtgroup_mode_str(enum rdtgrp_mode mode) 197fa7d9493SBabu Moger { 198fa7d9493SBabu Moger if (mode < RDT_MODE_SHAREABLE || mode >= RDT_NUM_MODES) 199fa7d9493SBabu Moger return "unknown"; 200fa7d9493SBabu Moger 201fa7d9493SBabu Moger return rdt_mode_str[mode]; 202fa7d9493SBabu Moger } 203fa7d9493SBabu Moger 204fa7d9493SBabu Moger /* set uid and gid of rdtgroup dirs and files to that of the creator */ 205fa7d9493SBabu Moger static int rdtgroup_kn_set_ugid(struct kernfs_node *kn) 206fa7d9493SBabu Moger { 207fa7d9493SBabu Moger struct iattr iattr = { .ia_valid = ATTR_UID | ATTR_GID, 208fa7d9493SBabu Moger .ia_uid = current_fsuid(), 209fa7d9493SBabu Moger .ia_gid = current_fsgid(), }; 210fa7d9493SBabu Moger 211fa7d9493SBabu Moger if (uid_eq(iattr.ia_uid, GLOBAL_ROOT_UID) && 212fa7d9493SBabu Moger gid_eq(iattr.ia_gid, GLOBAL_ROOT_GID)) 213fa7d9493SBabu Moger return 0; 214fa7d9493SBabu Moger 215fa7d9493SBabu Moger return kernfs_setattr(kn, &iattr); 216fa7d9493SBabu Moger } 217fa7d9493SBabu Moger 218fa7d9493SBabu Moger static int rdtgroup_add_file(struct kernfs_node *parent_kn, struct rftype *rft) 219fa7d9493SBabu Moger { 220fa7d9493SBabu Moger struct kernfs_node *kn; 221fa7d9493SBabu Moger int ret; 222fa7d9493SBabu Moger 223fa7d9493SBabu Moger kn = __kernfs_create_file(parent_kn, rft->name, rft->mode, 224fa7d9493SBabu Moger GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 225fa7d9493SBabu Moger 0, rft->kf_ops, rft, NULL, NULL); 226fa7d9493SBabu Moger if (IS_ERR(kn)) 227fa7d9493SBabu Moger return PTR_ERR(kn); 228fa7d9493SBabu Moger 229fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 230fa7d9493SBabu Moger if (ret) { 231fa7d9493SBabu Moger kernfs_remove(kn); 232fa7d9493SBabu Moger return ret; 233fa7d9493SBabu Moger } 234fa7d9493SBabu Moger 235fa7d9493SBabu Moger return 0; 236fa7d9493SBabu Moger } 237fa7d9493SBabu Moger 238fa7d9493SBabu Moger static int rdtgroup_seqfile_show(struct seq_file *m, void *arg) 239fa7d9493SBabu Moger { 240fa7d9493SBabu Moger struct kernfs_open_file *of = m->private; 241fa7d9493SBabu Moger struct rftype *rft = of->kn->priv; 242fa7d9493SBabu Moger 243fa7d9493SBabu Moger if (rft->seq_show) 244fa7d9493SBabu Moger return rft->seq_show(of, m, arg); 245fa7d9493SBabu Moger return 0; 246fa7d9493SBabu Moger } 247fa7d9493SBabu Moger 248fa7d9493SBabu Moger static ssize_t rdtgroup_file_write(struct kernfs_open_file *of, char *buf, 249fa7d9493SBabu Moger size_t nbytes, loff_t off) 250fa7d9493SBabu Moger { 251fa7d9493SBabu Moger struct rftype *rft = of->kn->priv; 252fa7d9493SBabu Moger 253fa7d9493SBabu Moger if (rft->write) 254fa7d9493SBabu Moger return rft->write(of, buf, nbytes, off); 255fa7d9493SBabu Moger 256fa7d9493SBabu Moger return -EINVAL; 257fa7d9493SBabu Moger } 258fa7d9493SBabu Moger 2592002d295SRikard Falkeborn static const struct kernfs_ops rdtgroup_kf_single_ops = { 260fa7d9493SBabu Moger .atomic_write_len = PAGE_SIZE, 261fa7d9493SBabu Moger .write = rdtgroup_file_write, 262fa7d9493SBabu Moger .seq_show = rdtgroup_seqfile_show, 263fa7d9493SBabu Moger }; 264fa7d9493SBabu Moger 2652002d295SRikard Falkeborn static const struct kernfs_ops kf_mondata_ops = { 266fa7d9493SBabu Moger .atomic_write_len = PAGE_SIZE, 267fa7d9493SBabu Moger .seq_show = rdtgroup_mondata_show, 268fa7d9493SBabu Moger }; 269fa7d9493SBabu Moger 270fa7d9493SBabu Moger static bool is_cpu_list(struct kernfs_open_file *of) 271fa7d9493SBabu Moger { 272fa7d9493SBabu Moger struct rftype *rft = of->kn->priv; 273fa7d9493SBabu Moger 274fa7d9493SBabu Moger return rft->flags & RFTYPE_FLAGS_CPUS_LIST; 275fa7d9493SBabu Moger } 276fa7d9493SBabu Moger 277fa7d9493SBabu Moger static int rdtgroup_cpus_show(struct kernfs_open_file *of, 278fa7d9493SBabu Moger struct seq_file *s, void *v) 279fa7d9493SBabu Moger { 280fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 281fa7d9493SBabu Moger struct cpumask *mask; 282fa7d9493SBabu Moger int ret = 0; 283fa7d9493SBabu Moger 284fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 285fa7d9493SBabu Moger 286fa7d9493SBabu Moger if (rdtgrp) { 287fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 288fa7d9493SBabu Moger if (!rdtgrp->plr->d) { 289fa7d9493SBabu Moger rdt_last_cmd_clear(); 290fa7d9493SBabu Moger rdt_last_cmd_puts("Cache domain offline\n"); 291fa7d9493SBabu Moger ret = -ENODEV; 292fa7d9493SBabu Moger } else { 293fa7d9493SBabu Moger mask = &rdtgrp->plr->d->cpu_mask; 294fa7d9493SBabu Moger seq_printf(s, is_cpu_list(of) ? 295fa7d9493SBabu Moger "%*pbl\n" : "%*pb\n", 296fa7d9493SBabu Moger cpumask_pr_args(mask)); 297fa7d9493SBabu Moger } 298fa7d9493SBabu Moger } else { 299fa7d9493SBabu Moger seq_printf(s, is_cpu_list(of) ? "%*pbl\n" : "%*pb\n", 300fa7d9493SBabu Moger cpumask_pr_args(&rdtgrp->cpu_mask)); 301fa7d9493SBabu Moger } 302fa7d9493SBabu Moger } else { 303fa7d9493SBabu Moger ret = -ENOENT; 304fa7d9493SBabu Moger } 305fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 306fa7d9493SBabu Moger 307fa7d9493SBabu Moger return ret; 308fa7d9493SBabu Moger } 309fa7d9493SBabu Moger 310fa7d9493SBabu Moger /* 311352940ecSBabu Moger * This is safe against resctrl_sched_in() called from __switch_to() 312fa7d9493SBabu Moger * because __switch_to() is executed with interrupts disabled. A local call 313d9f6e12fSIngo Molnar * from update_closid_rmid() is protected against __switch_to() because 314fa7d9493SBabu Moger * preemption is disabled. 315fa7d9493SBabu Moger */ 316fa7d9493SBabu Moger static void update_cpu_closid_rmid(void *info) 317fa7d9493SBabu Moger { 318fa7d9493SBabu Moger struct rdtgroup *r = info; 319fa7d9493SBabu Moger 320fa7d9493SBabu Moger if (r) { 321fa7d9493SBabu Moger this_cpu_write(pqr_state.default_closid, r->closid); 322fa7d9493SBabu Moger this_cpu_write(pqr_state.default_rmid, r->mon.rmid); 323fa7d9493SBabu Moger } 324fa7d9493SBabu Moger 325fa7d9493SBabu Moger /* 326fa7d9493SBabu Moger * We cannot unconditionally write the MSR because the current 327fa7d9493SBabu Moger * executing task might have its own closid selected. Just reuse 328fa7d9493SBabu Moger * the context switch code. 329fa7d9493SBabu Moger */ 3307fef0997SLinus Torvalds resctrl_sched_in(current); 331fa7d9493SBabu Moger } 332fa7d9493SBabu Moger 333fa7d9493SBabu Moger /* 334fa7d9493SBabu Moger * Update the PGR_ASSOC MSR on all cpus in @cpu_mask, 335fa7d9493SBabu Moger * 336fa7d9493SBabu Moger * Per task closids/rmids must have been set up before calling this function. 337fa7d9493SBabu Moger */ 338fa7d9493SBabu Moger static void 339fa7d9493SBabu Moger update_closid_rmid(const struct cpumask *cpu_mask, struct rdtgroup *r) 340fa7d9493SBabu Moger { 341fc3b618cSBabu Moger on_each_cpu_mask(cpu_mask, update_cpu_closid_rmid, r, 1); 342fa7d9493SBabu Moger } 343fa7d9493SBabu Moger 344fa7d9493SBabu Moger static int cpus_mon_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 345fa7d9493SBabu Moger cpumask_var_t tmpmask) 346fa7d9493SBabu Moger { 347fa7d9493SBabu Moger struct rdtgroup *prgrp = rdtgrp->mon.parent, *crgrp; 348fa7d9493SBabu Moger struct list_head *head; 349fa7d9493SBabu Moger 350fa7d9493SBabu Moger /* Check whether cpus belong to parent ctrl group */ 351fa7d9493SBabu Moger cpumask_andnot(tmpmask, newmask, &prgrp->cpu_mask); 3523a5ff1f6SYury Norov if (!cpumask_empty(tmpmask)) { 353723f1a0dSBabu Moger rdt_last_cmd_puts("Can only add CPUs to mongroup that belong to parent\n"); 354fa7d9493SBabu Moger return -EINVAL; 355fa7d9493SBabu Moger } 356fa7d9493SBabu Moger 357fa7d9493SBabu Moger /* Check whether cpus are dropped from this group */ 358fa7d9493SBabu Moger cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 3593a5ff1f6SYury Norov if (!cpumask_empty(tmpmask)) { 360fa7d9493SBabu Moger /* Give any dropped cpus to parent rdtgroup */ 361fa7d9493SBabu Moger cpumask_or(&prgrp->cpu_mask, &prgrp->cpu_mask, tmpmask); 362fa7d9493SBabu Moger update_closid_rmid(tmpmask, prgrp); 363fa7d9493SBabu Moger } 364fa7d9493SBabu Moger 365fa7d9493SBabu Moger /* 366fa7d9493SBabu Moger * If we added cpus, remove them from previous group that owned them 367fa7d9493SBabu Moger * and update per-cpu rmid 368fa7d9493SBabu Moger */ 369fa7d9493SBabu Moger cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 3703a5ff1f6SYury Norov if (!cpumask_empty(tmpmask)) { 371fa7d9493SBabu Moger head = &prgrp->mon.crdtgrp_list; 372fa7d9493SBabu Moger list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 373fa7d9493SBabu Moger if (crgrp == rdtgrp) 374fa7d9493SBabu Moger continue; 375fa7d9493SBabu Moger cpumask_andnot(&crgrp->cpu_mask, &crgrp->cpu_mask, 376fa7d9493SBabu Moger tmpmask); 377fa7d9493SBabu Moger } 378fa7d9493SBabu Moger update_closid_rmid(tmpmask, rdtgrp); 379fa7d9493SBabu Moger } 380fa7d9493SBabu Moger 381fa7d9493SBabu Moger /* Done pushing/pulling - update this group with new mask */ 382fa7d9493SBabu Moger cpumask_copy(&rdtgrp->cpu_mask, newmask); 383fa7d9493SBabu Moger 384fa7d9493SBabu Moger return 0; 385fa7d9493SBabu Moger } 386fa7d9493SBabu Moger 387fa7d9493SBabu Moger static void cpumask_rdtgrp_clear(struct rdtgroup *r, struct cpumask *m) 388fa7d9493SBabu Moger { 389fa7d9493SBabu Moger struct rdtgroup *crgrp; 390fa7d9493SBabu Moger 391fa7d9493SBabu Moger cpumask_andnot(&r->cpu_mask, &r->cpu_mask, m); 392fa7d9493SBabu Moger /* update the child mon group masks as well*/ 393fa7d9493SBabu Moger list_for_each_entry(crgrp, &r->mon.crdtgrp_list, mon.crdtgrp_list) 394fa7d9493SBabu Moger cpumask_and(&crgrp->cpu_mask, &r->cpu_mask, &crgrp->cpu_mask); 395fa7d9493SBabu Moger } 396fa7d9493SBabu Moger 397fa7d9493SBabu Moger static int cpus_ctrl_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 398fa7d9493SBabu Moger cpumask_var_t tmpmask, cpumask_var_t tmpmask1) 399fa7d9493SBabu Moger { 400fa7d9493SBabu Moger struct rdtgroup *r, *crgrp; 401fa7d9493SBabu Moger struct list_head *head; 402fa7d9493SBabu Moger 403fa7d9493SBabu Moger /* Check whether cpus are dropped from this group */ 404fa7d9493SBabu Moger cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 4053a5ff1f6SYury Norov if (!cpumask_empty(tmpmask)) { 406fa7d9493SBabu Moger /* Can't drop from default group */ 407fa7d9493SBabu Moger if (rdtgrp == &rdtgroup_default) { 408fa7d9493SBabu Moger rdt_last_cmd_puts("Can't drop CPUs from default group\n"); 409fa7d9493SBabu Moger return -EINVAL; 410fa7d9493SBabu Moger } 411fa7d9493SBabu Moger 412fa7d9493SBabu Moger /* Give any dropped cpus to rdtgroup_default */ 413fa7d9493SBabu Moger cpumask_or(&rdtgroup_default.cpu_mask, 414fa7d9493SBabu Moger &rdtgroup_default.cpu_mask, tmpmask); 415fa7d9493SBabu Moger update_closid_rmid(tmpmask, &rdtgroup_default); 416fa7d9493SBabu Moger } 417fa7d9493SBabu Moger 418fa7d9493SBabu Moger /* 419fa7d9493SBabu Moger * If we added cpus, remove them from previous group and 420fa7d9493SBabu Moger * the prev group's child groups that owned them 421fa7d9493SBabu Moger * and update per-cpu closid/rmid. 422fa7d9493SBabu Moger */ 423fa7d9493SBabu Moger cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 4243a5ff1f6SYury Norov if (!cpumask_empty(tmpmask)) { 425fa7d9493SBabu Moger list_for_each_entry(r, &rdt_all_groups, rdtgroup_list) { 426fa7d9493SBabu Moger if (r == rdtgrp) 427fa7d9493SBabu Moger continue; 428fa7d9493SBabu Moger cpumask_and(tmpmask1, &r->cpu_mask, tmpmask); 4293a5ff1f6SYury Norov if (!cpumask_empty(tmpmask1)) 430fa7d9493SBabu Moger cpumask_rdtgrp_clear(r, tmpmask1); 431fa7d9493SBabu Moger } 432fa7d9493SBabu Moger update_closid_rmid(tmpmask, rdtgrp); 433fa7d9493SBabu Moger } 434fa7d9493SBabu Moger 435fa7d9493SBabu Moger /* Done pushing/pulling - update this group with new mask */ 436fa7d9493SBabu Moger cpumask_copy(&rdtgrp->cpu_mask, newmask); 437fa7d9493SBabu Moger 438fa7d9493SBabu Moger /* 439fa7d9493SBabu Moger * Clear child mon group masks since there is a new parent mask 440fa7d9493SBabu Moger * now and update the rmid for the cpus the child lost. 441fa7d9493SBabu Moger */ 442fa7d9493SBabu Moger head = &rdtgrp->mon.crdtgrp_list; 443fa7d9493SBabu Moger list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 444fa7d9493SBabu Moger cpumask_and(tmpmask, &rdtgrp->cpu_mask, &crgrp->cpu_mask); 445fa7d9493SBabu Moger update_closid_rmid(tmpmask, rdtgrp); 446fa7d9493SBabu Moger cpumask_clear(&crgrp->cpu_mask); 447fa7d9493SBabu Moger } 448fa7d9493SBabu Moger 449fa7d9493SBabu Moger return 0; 450fa7d9493SBabu Moger } 451fa7d9493SBabu Moger 452fa7d9493SBabu Moger static ssize_t rdtgroup_cpus_write(struct kernfs_open_file *of, 453fa7d9493SBabu Moger char *buf, size_t nbytes, loff_t off) 454fa7d9493SBabu Moger { 455fa7d9493SBabu Moger cpumask_var_t tmpmask, newmask, tmpmask1; 456fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 457fa7d9493SBabu Moger int ret; 458fa7d9493SBabu Moger 459fa7d9493SBabu Moger if (!buf) 460fa7d9493SBabu Moger return -EINVAL; 461fa7d9493SBabu Moger 462fa7d9493SBabu Moger if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 463fa7d9493SBabu Moger return -ENOMEM; 464fa7d9493SBabu Moger if (!zalloc_cpumask_var(&newmask, GFP_KERNEL)) { 465fa7d9493SBabu Moger free_cpumask_var(tmpmask); 466fa7d9493SBabu Moger return -ENOMEM; 467fa7d9493SBabu Moger } 468fa7d9493SBabu Moger if (!zalloc_cpumask_var(&tmpmask1, GFP_KERNEL)) { 469fa7d9493SBabu Moger free_cpumask_var(tmpmask); 470fa7d9493SBabu Moger free_cpumask_var(newmask); 471fa7d9493SBabu Moger return -ENOMEM; 472fa7d9493SBabu Moger } 473fa7d9493SBabu Moger 474fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 475fa7d9493SBabu Moger if (!rdtgrp) { 476fa7d9493SBabu Moger ret = -ENOENT; 477fa7d9493SBabu Moger goto unlock; 478fa7d9493SBabu Moger } 479fa7d9493SBabu Moger 480fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 481fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 482fa7d9493SBabu Moger ret = -EINVAL; 483723f1a0dSBabu Moger rdt_last_cmd_puts("Pseudo-locking in progress\n"); 484fa7d9493SBabu Moger goto unlock; 485fa7d9493SBabu Moger } 486fa7d9493SBabu Moger 487fa7d9493SBabu Moger if (is_cpu_list(of)) 488fa7d9493SBabu Moger ret = cpulist_parse(buf, newmask); 489fa7d9493SBabu Moger else 490fa7d9493SBabu Moger ret = cpumask_parse(buf, newmask); 491fa7d9493SBabu Moger 492fa7d9493SBabu Moger if (ret) { 493723f1a0dSBabu Moger rdt_last_cmd_puts("Bad CPU list/mask\n"); 494fa7d9493SBabu Moger goto unlock; 495fa7d9493SBabu Moger } 496fa7d9493SBabu Moger 497fa7d9493SBabu Moger /* check that user didn't specify any offline cpus */ 498fa7d9493SBabu Moger cpumask_andnot(tmpmask, newmask, cpu_online_mask); 4993a5ff1f6SYury Norov if (!cpumask_empty(tmpmask)) { 500fa7d9493SBabu Moger ret = -EINVAL; 501723f1a0dSBabu Moger rdt_last_cmd_puts("Can only assign online CPUs\n"); 502fa7d9493SBabu Moger goto unlock; 503fa7d9493SBabu Moger } 504fa7d9493SBabu Moger 505fa7d9493SBabu Moger if (rdtgrp->type == RDTCTRL_GROUP) 506fa7d9493SBabu Moger ret = cpus_ctrl_write(rdtgrp, newmask, tmpmask, tmpmask1); 507fa7d9493SBabu Moger else if (rdtgrp->type == RDTMON_GROUP) 508fa7d9493SBabu Moger ret = cpus_mon_write(rdtgrp, newmask, tmpmask); 509fa7d9493SBabu Moger else 510fa7d9493SBabu Moger ret = -EINVAL; 511fa7d9493SBabu Moger 512fa7d9493SBabu Moger unlock: 513fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 514fa7d9493SBabu Moger free_cpumask_var(tmpmask); 515fa7d9493SBabu Moger free_cpumask_var(newmask); 516fa7d9493SBabu Moger free_cpumask_var(tmpmask1); 517fa7d9493SBabu Moger 518fa7d9493SBabu Moger return ret ?: nbytes; 519fa7d9493SBabu Moger } 520fa7d9493SBabu Moger 52175899924SXiaochen Shen /** 52275899924SXiaochen Shen * rdtgroup_remove - the helper to remove resource group safely 52375899924SXiaochen Shen * @rdtgrp: resource group to remove 52475899924SXiaochen Shen * 52575899924SXiaochen Shen * On resource group creation via a mkdir, an extra kernfs_node reference is 52675899924SXiaochen Shen * taken to ensure that the rdtgroup structure remains accessible for the 52775899924SXiaochen Shen * rdtgroup_kn_unlock() calls where it is removed. 52875899924SXiaochen Shen * 52975899924SXiaochen Shen * Drop the extra reference here, then free the rdtgroup structure. 53075899924SXiaochen Shen * 53175899924SXiaochen Shen * Return: void 53275899924SXiaochen Shen */ 53375899924SXiaochen Shen static void rdtgroup_remove(struct rdtgroup *rdtgrp) 53475899924SXiaochen Shen { 53575899924SXiaochen Shen kernfs_put(rdtgrp->kn); 53675899924SXiaochen Shen kfree(rdtgrp); 53775899924SXiaochen Shen } 53875899924SXiaochen Shen 539ae28d1aaSFenghua Yu static void _update_task_closid_rmid(void *task) 540fa7d9493SBabu Moger { 541fa7d9493SBabu Moger /* 542ae28d1aaSFenghua Yu * If the task is still current on this CPU, update PQR_ASSOC MSR. 543ae28d1aaSFenghua Yu * Otherwise, the MSR is updated when the task is scheduled in. 544fa7d9493SBabu Moger */ 545ae28d1aaSFenghua Yu if (task == current) 5467fef0997SLinus Torvalds resctrl_sched_in(task); 547fa7d9493SBabu Moger } 548fa7d9493SBabu Moger 549ae28d1aaSFenghua Yu static void update_task_closid_rmid(struct task_struct *t) 550ae28d1aaSFenghua Yu { 551ae28d1aaSFenghua Yu if (IS_ENABLED(CONFIG_SMP) && task_curr(t)) 552ae28d1aaSFenghua Yu smp_call_function_single(task_cpu(t), _update_task_closid_rmid, t, 1); 553ae28d1aaSFenghua Yu else 554ae28d1aaSFenghua Yu _update_task_closid_rmid(t); 555fa7d9493SBabu Moger } 556fa7d9493SBabu Moger 557fa7d9493SBabu Moger static int __rdtgroup_move_task(struct task_struct *tsk, 558fa7d9493SBabu Moger struct rdtgroup *rdtgrp) 559fa7d9493SBabu Moger { 560a0195f31SFenghua Yu /* If the task is already in rdtgrp, no need to move the task. */ 561a0195f31SFenghua Yu if ((rdtgrp->type == RDTCTRL_GROUP && tsk->closid == rdtgrp->closid && 562a0195f31SFenghua Yu tsk->rmid == rdtgrp->mon.rmid) || 563a0195f31SFenghua Yu (rdtgrp->type == RDTMON_GROUP && tsk->rmid == rdtgrp->mon.rmid && 564a0195f31SFenghua Yu tsk->closid == rdtgrp->mon.parent->closid)) 565a0195f31SFenghua Yu return 0; 566a0195f31SFenghua Yu 567fa7d9493SBabu Moger /* 568ae28d1aaSFenghua Yu * Set the task's closid/rmid before the PQR_ASSOC MSR can be 569ae28d1aaSFenghua Yu * updated by them. 570ae28d1aaSFenghua Yu * 571ae28d1aaSFenghua Yu * For ctrl_mon groups, move both closid and rmid. 572fa7d9493SBabu Moger * For monitor groups, can move the tasks only from 573fa7d9493SBabu Moger * their parent CTRL group. 574fa7d9493SBabu Moger */ 575ae28d1aaSFenghua Yu 576fa7d9493SBabu Moger if (rdtgrp->type == RDTCTRL_GROUP) { 5776d3b47ddSValentin Schneider WRITE_ONCE(tsk->closid, rdtgrp->closid); 5786d3b47ddSValentin Schneider WRITE_ONCE(tsk->rmid, rdtgrp->mon.rmid); 579fa7d9493SBabu Moger } else if (rdtgrp->type == RDTMON_GROUP) { 580fa7d9493SBabu Moger if (rdtgrp->mon.parent->closid == tsk->closid) { 5816d3b47ddSValentin Schneider WRITE_ONCE(tsk->rmid, rdtgrp->mon.rmid); 582fa7d9493SBabu Moger } else { 583fa7d9493SBabu Moger rdt_last_cmd_puts("Can't move task to different control group\n"); 584ae28d1aaSFenghua Yu return -EINVAL; 585fa7d9493SBabu Moger } 586fa7d9493SBabu Moger } 587ae28d1aaSFenghua Yu 588ae28d1aaSFenghua Yu /* 589ae28d1aaSFenghua Yu * Ensure the task's closid and rmid are written before determining if 590ae28d1aaSFenghua Yu * the task is current that will decide if it will be interrupted. 591fe1f0714SPeter Newman * This pairs with the full barrier between the rq->curr update and 592fe1f0714SPeter Newman * resctrl_sched_in() during context switch. 593ae28d1aaSFenghua Yu */ 594fe1f0714SPeter Newman smp_mb(); 595ae28d1aaSFenghua Yu 596ae28d1aaSFenghua Yu /* 597ae28d1aaSFenghua Yu * By now, the task's closid and rmid are set. If the task is current 598ae28d1aaSFenghua Yu * on a CPU, the PQR_ASSOC MSR needs to be updated to make the resource 599ae28d1aaSFenghua Yu * group go into effect. If the task is not current, the MSR will be 600ae28d1aaSFenghua Yu * updated when the task is scheduled in. 601ae28d1aaSFenghua Yu */ 602ae28d1aaSFenghua Yu update_task_closid_rmid(tsk); 603ae28d1aaSFenghua Yu 604ae28d1aaSFenghua Yu return 0; 605fa7d9493SBabu Moger } 606fa7d9493SBabu Moger 607e6b2fac3SJames Morse static bool is_closid_match(struct task_struct *t, struct rdtgroup *r) 608e6b2fac3SJames Morse { 609e6b2fac3SJames Morse return (rdt_alloc_capable && 610e6b2fac3SJames Morse (r->type == RDTCTRL_GROUP) && (t->closid == r->closid)); 611e6b2fac3SJames Morse } 612e6b2fac3SJames Morse 613e6b2fac3SJames Morse static bool is_rmid_match(struct task_struct *t, struct rdtgroup *r) 614e6b2fac3SJames Morse { 615e6b2fac3SJames Morse return (rdt_mon_capable && 616e6b2fac3SJames Morse (r->type == RDTMON_GROUP) && (t->rmid == r->mon.rmid)); 617e6b2fac3SJames Morse } 618e6b2fac3SJames Morse 619fa7d9493SBabu Moger /** 620fa7d9493SBabu Moger * rdtgroup_tasks_assigned - Test if tasks have been assigned to resource group 621fa7d9493SBabu Moger * @r: Resource group 622fa7d9493SBabu Moger * 623fa7d9493SBabu Moger * Return: 1 if tasks have been assigned to @r, 0 otherwise 624fa7d9493SBabu Moger */ 625fa7d9493SBabu Moger int rdtgroup_tasks_assigned(struct rdtgroup *r) 626fa7d9493SBabu Moger { 627fa7d9493SBabu Moger struct task_struct *p, *t; 628fa7d9493SBabu Moger int ret = 0; 629fa7d9493SBabu Moger 630fa7d9493SBabu Moger lockdep_assert_held(&rdtgroup_mutex); 631fa7d9493SBabu Moger 632fa7d9493SBabu Moger rcu_read_lock(); 633fa7d9493SBabu Moger for_each_process_thread(p, t) { 634e6b2fac3SJames Morse if (is_closid_match(t, r) || is_rmid_match(t, r)) { 635fa7d9493SBabu Moger ret = 1; 636fa7d9493SBabu Moger break; 637fa7d9493SBabu Moger } 638fa7d9493SBabu Moger } 639fa7d9493SBabu Moger rcu_read_unlock(); 640fa7d9493SBabu Moger 641fa7d9493SBabu Moger return ret; 642fa7d9493SBabu Moger } 643fa7d9493SBabu Moger 644fa7d9493SBabu Moger static int rdtgroup_task_write_permission(struct task_struct *task, 645fa7d9493SBabu Moger struct kernfs_open_file *of) 646fa7d9493SBabu Moger { 647fa7d9493SBabu Moger const struct cred *tcred = get_task_cred(task); 648fa7d9493SBabu Moger const struct cred *cred = current_cred(); 649fa7d9493SBabu Moger int ret = 0; 650fa7d9493SBabu Moger 651fa7d9493SBabu Moger /* 652fa7d9493SBabu Moger * Even if we're attaching all tasks in the thread group, we only 653fa7d9493SBabu Moger * need to check permissions on one of them. 654fa7d9493SBabu Moger */ 655fa7d9493SBabu Moger if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) && 656fa7d9493SBabu Moger !uid_eq(cred->euid, tcred->uid) && 657fa7d9493SBabu Moger !uid_eq(cred->euid, tcred->suid)) { 658fa7d9493SBabu Moger rdt_last_cmd_printf("No permission to move task %d\n", task->pid); 659fa7d9493SBabu Moger ret = -EPERM; 660fa7d9493SBabu Moger } 661fa7d9493SBabu Moger 662fa7d9493SBabu Moger put_cred(tcred); 663fa7d9493SBabu Moger return ret; 664fa7d9493SBabu Moger } 665fa7d9493SBabu Moger 666fa7d9493SBabu Moger static int rdtgroup_move_task(pid_t pid, struct rdtgroup *rdtgrp, 667fa7d9493SBabu Moger struct kernfs_open_file *of) 668fa7d9493SBabu Moger { 669fa7d9493SBabu Moger struct task_struct *tsk; 670fa7d9493SBabu Moger int ret; 671fa7d9493SBabu Moger 672fa7d9493SBabu Moger rcu_read_lock(); 673fa7d9493SBabu Moger if (pid) { 674fa7d9493SBabu Moger tsk = find_task_by_vpid(pid); 675fa7d9493SBabu Moger if (!tsk) { 676fa7d9493SBabu Moger rcu_read_unlock(); 677fa7d9493SBabu Moger rdt_last_cmd_printf("No task %d\n", pid); 678fa7d9493SBabu Moger return -ESRCH; 679fa7d9493SBabu Moger } 680fa7d9493SBabu Moger } else { 681fa7d9493SBabu Moger tsk = current; 682fa7d9493SBabu Moger } 683fa7d9493SBabu Moger 684fa7d9493SBabu Moger get_task_struct(tsk); 685fa7d9493SBabu Moger rcu_read_unlock(); 686fa7d9493SBabu Moger 687fa7d9493SBabu Moger ret = rdtgroup_task_write_permission(tsk, of); 688fa7d9493SBabu Moger if (!ret) 689fa7d9493SBabu Moger ret = __rdtgroup_move_task(tsk, rdtgrp); 690fa7d9493SBabu Moger 691fa7d9493SBabu Moger put_task_struct(tsk); 692fa7d9493SBabu Moger return ret; 693fa7d9493SBabu Moger } 694fa7d9493SBabu Moger 695fa7d9493SBabu Moger static ssize_t rdtgroup_tasks_write(struct kernfs_open_file *of, 696fa7d9493SBabu Moger char *buf, size_t nbytes, loff_t off) 697fa7d9493SBabu Moger { 698fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 699fa7d9493SBabu Moger int ret = 0; 700fa7d9493SBabu Moger pid_t pid; 701fa7d9493SBabu Moger 702fa7d9493SBabu Moger if (kstrtoint(strstrip(buf), 0, &pid) || pid < 0) 703fa7d9493SBabu Moger return -EINVAL; 704fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 705fa7d9493SBabu Moger if (!rdtgrp) { 706fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 707fa7d9493SBabu Moger return -ENOENT; 708fa7d9493SBabu Moger } 709fa7d9493SBabu Moger rdt_last_cmd_clear(); 710fa7d9493SBabu Moger 711fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 712fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 713fa7d9493SBabu Moger ret = -EINVAL; 714723f1a0dSBabu Moger rdt_last_cmd_puts("Pseudo-locking in progress\n"); 715fa7d9493SBabu Moger goto unlock; 716fa7d9493SBabu Moger } 717fa7d9493SBabu Moger 718fa7d9493SBabu Moger ret = rdtgroup_move_task(pid, rdtgrp, of); 719fa7d9493SBabu Moger 720fa7d9493SBabu Moger unlock: 721fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 722fa7d9493SBabu Moger 723fa7d9493SBabu Moger return ret ?: nbytes; 724fa7d9493SBabu Moger } 725fa7d9493SBabu Moger 726fa7d9493SBabu Moger static void show_rdt_tasks(struct rdtgroup *r, struct seq_file *s) 727fa7d9493SBabu Moger { 728fa7d9493SBabu Moger struct task_struct *p, *t; 729fa7d9493SBabu Moger 730fa7d9493SBabu Moger rcu_read_lock(); 731fa7d9493SBabu Moger for_each_process_thread(p, t) { 732e6b2fac3SJames Morse if (is_closid_match(t, r) || is_rmid_match(t, r)) 733fa7d9493SBabu Moger seq_printf(s, "%d\n", t->pid); 734fa7d9493SBabu Moger } 735fa7d9493SBabu Moger rcu_read_unlock(); 736fa7d9493SBabu Moger } 737fa7d9493SBabu Moger 738fa7d9493SBabu Moger static int rdtgroup_tasks_show(struct kernfs_open_file *of, 739fa7d9493SBabu Moger struct seq_file *s, void *v) 740fa7d9493SBabu Moger { 741fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 742fa7d9493SBabu Moger int ret = 0; 743fa7d9493SBabu Moger 744fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 745fa7d9493SBabu Moger if (rdtgrp) 746fa7d9493SBabu Moger show_rdt_tasks(rdtgrp, s); 747fa7d9493SBabu Moger else 748fa7d9493SBabu Moger ret = -ENOENT; 749fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 750fa7d9493SBabu Moger 751fa7d9493SBabu Moger return ret; 752fa7d9493SBabu Moger } 753fa7d9493SBabu Moger 754e79f15a4SChen Yu #ifdef CONFIG_PROC_CPU_RESCTRL 755e79f15a4SChen Yu 756e79f15a4SChen Yu /* 757e79f15a4SChen Yu * A task can only be part of one resctrl control group and of one monitor 758e79f15a4SChen Yu * group which is associated to that control group. 759e79f15a4SChen Yu * 760e79f15a4SChen Yu * 1) res: 761e79f15a4SChen Yu * mon: 762e79f15a4SChen Yu * 763e79f15a4SChen Yu * resctrl is not available. 764e79f15a4SChen Yu * 765e79f15a4SChen Yu * 2) res:/ 766e79f15a4SChen Yu * mon: 767e79f15a4SChen Yu * 768e79f15a4SChen Yu * Task is part of the root resctrl control group, and it is not associated 769e79f15a4SChen Yu * to any monitor group. 770e79f15a4SChen Yu * 771e79f15a4SChen Yu * 3) res:/ 772e79f15a4SChen Yu * mon:mon0 773e79f15a4SChen Yu * 774e79f15a4SChen Yu * Task is part of the root resctrl control group and monitor group mon0. 775e79f15a4SChen Yu * 776e79f15a4SChen Yu * 4) res:group0 777e79f15a4SChen Yu * mon: 778e79f15a4SChen Yu * 779e79f15a4SChen Yu * Task is part of resctrl control group group0, and it is not associated 780e79f15a4SChen Yu * to any monitor group. 781e79f15a4SChen Yu * 782e79f15a4SChen Yu * 5) res:group0 783e79f15a4SChen Yu * mon:mon1 784e79f15a4SChen Yu * 785e79f15a4SChen Yu * Task is part of resctrl control group group0 and monitor group mon1. 786e79f15a4SChen Yu */ 787e79f15a4SChen Yu int proc_resctrl_show(struct seq_file *s, struct pid_namespace *ns, 788e79f15a4SChen Yu struct pid *pid, struct task_struct *tsk) 789e79f15a4SChen Yu { 790e79f15a4SChen Yu struct rdtgroup *rdtg; 791e79f15a4SChen Yu int ret = 0; 792e79f15a4SChen Yu 793e79f15a4SChen Yu mutex_lock(&rdtgroup_mutex); 794e79f15a4SChen Yu 795e79f15a4SChen Yu /* Return empty if resctrl has not been mounted. */ 796e79f15a4SChen Yu if (!static_branch_unlikely(&rdt_enable_key)) { 797e79f15a4SChen Yu seq_puts(s, "res:\nmon:\n"); 798e79f15a4SChen Yu goto unlock; 799e79f15a4SChen Yu } 800e79f15a4SChen Yu 801e79f15a4SChen Yu list_for_each_entry(rdtg, &rdt_all_groups, rdtgroup_list) { 802e79f15a4SChen Yu struct rdtgroup *crg; 803e79f15a4SChen Yu 804e79f15a4SChen Yu /* 805e79f15a4SChen Yu * Task information is only relevant for shareable 806e79f15a4SChen Yu * and exclusive groups. 807e79f15a4SChen Yu */ 808e79f15a4SChen Yu if (rdtg->mode != RDT_MODE_SHAREABLE && 809e79f15a4SChen Yu rdtg->mode != RDT_MODE_EXCLUSIVE) 810e79f15a4SChen Yu continue; 811e79f15a4SChen Yu 812e79f15a4SChen Yu if (rdtg->closid != tsk->closid) 813e79f15a4SChen Yu continue; 814e79f15a4SChen Yu 815e79f15a4SChen Yu seq_printf(s, "res:%s%s\n", (rdtg == &rdtgroup_default) ? "/" : "", 816e79f15a4SChen Yu rdtg->kn->name); 817e79f15a4SChen Yu seq_puts(s, "mon:"); 818e79f15a4SChen Yu list_for_each_entry(crg, &rdtg->mon.crdtgrp_list, 819e79f15a4SChen Yu mon.crdtgrp_list) { 820e79f15a4SChen Yu if (tsk->rmid != crg->mon.rmid) 821e79f15a4SChen Yu continue; 822e79f15a4SChen Yu seq_printf(s, "%s", crg->kn->name); 823e79f15a4SChen Yu break; 824e79f15a4SChen Yu } 825e79f15a4SChen Yu seq_putc(s, '\n'); 826e79f15a4SChen Yu goto unlock; 827e79f15a4SChen Yu } 828e79f15a4SChen Yu /* 829e79f15a4SChen Yu * The above search should succeed. Otherwise return 830e79f15a4SChen Yu * with an error. 831e79f15a4SChen Yu */ 832e79f15a4SChen Yu ret = -ENOENT; 833e79f15a4SChen Yu unlock: 834e79f15a4SChen Yu mutex_unlock(&rdtgroup_mutex); 835e79f15a4SChen Yu 836e79f15a4SChen Yu return ret; 837e79f15a4SChen Yu } 838e79f15a4SChen Yu #endif 839e79f15a4SChen Yu 840fa7d9493SBabu Moger static int rdt_last_cmd_status_show(struct kernfs_open_file *of, 841fa7d9493SBabu Moger struct seq_file *seq, void *v) 842fa7d9493SBabu Moger { 843fa7d9493SBabu Moger int len; 844fa7d9493SBabu Moger 845fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 846fa7d9493SBabu Moger len = seq_buf_used(&last_cmd_status); 847fa7d9493SBabu Moger if (len) 848fa7d9493SBabu Moger seq_printf(seq, "%.*s", len, last_cmd_status_buf); 849fa7d9493SBabu Moger else 850fa7d9493SBabu Moger seq_puts(seq, "ok\n"); 851fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 852fa7d9493SBabu Moger return 0; 853fa7d9493SBabu Moger } 854fa7d9493SBabu Moger 855fa7d9493SBabu Moger static int rdt_num_closids_show(struct kernfs_open_file *of, 856fa7d9493SBabu Moger struct seq_file *seq, void *v) 857fa7d9493SBabu Moger { 858f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 859fa7d9493SBabu Moger 8603183e87cSJames Morse seq_printf(seq, "%u\n", s->num_closid); 861fa7d9493SBabu Moger return 0; 862fa7d9493SBabu Moger } 863fa7d9493SBabu Moger 864fa7d9493SBabu Moger static int rdt_default_ctrl_show(struct kernfs_open_file *of, 865fa7d9493SBabu Moger struct seq_file *seq, void *v) 866fa7d9493SBabu Moger { 867f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 868f2594492SJames Morse struct rdt_resource *r = s->res; 869fa7d9493SBabu Moger 870fa7d9493SBabu Moger seq_printf(seq, "%x\n", r->default_ctrl); 871fa7d9493SBabu Moger return 0; 872fa7d9493SBabu Moger } 873fa7d9493SBabu Moger 874fa7d9493SBabu Moger static int rdt_min_cbm_bits_show(struct kernfs_open_file *of, 875fa7d9493SBabu Moger struct seq_file *seq, void *v) 876fa7d9493SBabu Moger { 877f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 878f2594492SJames Morse struct rdt_resource *r = s->res; 879fa7d9493SBabu Moger 880fa7d9493SBabu Moger seq_printf(seq, "%u\n", r->cache.min_cbm_bits); 881fa7d9493SBabu Moger return 0; 882fa7d9493SBabu Moger } 883fa7d9493SBabu Moger 884fa7d9493SBabu Moger static int rdt_shareable_bits_show(struct kernfs_open_file *of, 885fa7d9493SBabu Moger struct seq_file *seq, void *v) 886fa7d9493SBabu Moger { 887f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 888f2594492SJames Morse struct rdt_resource *r = s->res; 889fa7d9493SBabu Moger 890fa7d9493SBabu Moger seq_printf(seq, "%x\n", r->cache.shareable_bits); 891fa7d9493SBabu Moger return 0; 892fa7d9493SBabu Moger } 893fa7d9493SBabu Moger 894fa7d9493SBabu Moger /** 895fa7d9493SBabu Moger * rdt_bit_usage_show - Display current usage of resources 896fa7d9493SBabu Moger * 897fa7d9493SBabu Moger * A domain is a shared resource that can now be allocated differently. Here 898fa7d9493SBabu Moger * we display the current regions of the domain as an annotated bitmask. 899fa7d9493SBabu Moger * For each domain of this resource its allocation bitmask 900fa7d9493SBabu Moger * is annotated as below to indicate the current usage of the corresponding bit: 901fa7d9493SBabu Moger * 0 - currently unused 902fa7d9493SBabu Moger * X - currently available for sharing and used by software and hardware 903fa7d9493SBabu Moger * H - currently used by hardware only but available for software use 904fa7d9493SBabu Moger * S - currently used and shareable by software only 905fa7d9493SBabu Moger * E - currently used exclusively by one resource group 906fa7d9493SBabu Moger * P - currently pseudo-locked by one resource group 907fa7d9493SBabu Moger */ 908fa7d9493SBabu Moger static int rdt_bit_usage_show(struct kernfs_open_file *of, 909fa7d9493SBabu Moger struct seq_file *seq, void *v) 910fa7d9493SBabu Moger { 911f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 91232f010deSReinette Chatre /* 91332f010deSReinette Chatre * Use unsigned long even though only 32 bits are used to ensure 91432f010deSReinette Chatre * test_bit() is used safely. 91532f010deSReinette Chatre */ 91632f010deSReinette Chatre unsigned long sw_shareable = 0, hw_shareable = 0; 91732f010deSReinette Chatre unsigned long exclusive = 0, pseudo_locked = 0; 918f2594492SJames Morse struct rdt_resource *r = s->res; 919fa7d9493SBabu Moger struct rdt_domain *dom; 920fa7d9493SBabu Moger int i, hwb, swb, excl, psl; 921fa7d9493SBabu Moger enum rdtgrp_mode mode; 922fa7d9493SBabu Moger bool sep = false; 923f07e9d02SJames Morse u32 ctrl_val; 924fa7d9493SBabu Moger 925fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 926fa7d9493SBabu Moger hw_shareable = r->cache.shareable_bits; 927fa7d9493SBabu Moger list_for_each_entry(dom, &r->domains, list) { 928fa7d9493SBabu Moger if (sep) 929fa7d9493SBabu Moger seq_putc(seq, ';'); 930fa7d9493SBabu Moger sw_shareable = 0; 931fa7d9493SBabu Moger exclusive = 0; 932fa7d9493SBabu Moger seq_printf(seq, "%d=", dom->id); 933f07e9d02SJames Morse for (i = 0; i < closids_supported(); i++) { 934fa7d9493SBabu Moger if (!closid_allocated(i)) 935fa7d9493SBabu Moger continue; 936111136e6SJames Morse ctrl_val = resctrl_arch_get_config(r, dom, i, 937111136e6SJames Morse s->conf_type); 938fa7d9493SBabu Moger mode = rdtgroup_mode_by_closid(i); 939fa7d9493SBabu Moger switch (mode) { 940fa7d9493SBabu Moger case RDT_MODE_SHAREABLE: 941f07e9d02SJames Morse sw_shareable |= ctrl_val; 942fa7d9493SBabu Moger break; 943fa7d9493SBabu Moger case RDT_MODE_EXCLUSIVE: 944f07e9d02SJames Morse exclusive |= ctrl_val; 945fa7d9493SBabu Moger break; 946fa7d9493SBabu Moger case RDT_MODE_PSEUDO_LOCKSETUP: 947fa7d9493SBabu Moger /* 948fa7d9493SBabu Moger * RDT_MODE_PSEUDO_LOCKSETUP is possible 949fa7d9493SBabu Moger * here but not included since the CBM 950fa7d9493SBabu Moger * associated with this CLOSID in this mode 951fa7d9493SBabu Moger * is not initialized and no task or cpu can be 952fa7d9493SBabu Moger * assigned this CLOSID. 953fa7d9493SBabu Moger */ 954fa7d9493SBabu Moger break; 955fa7d9493SBabu Moger case RDT_MODE_PSEUDO_LOCKED: 956fa7d9493SBabu Moger case RDT_NUM_MODES: 957fa7d9493SBabu Moger WARN(1, 958fa7d9493SBabu Moger "invalid mode for closid %d\n", i); 959fa7d9493SBabu Moger break; 960fa7d9493SBabu Moger } 961fa7d9493SBabu Moger } 962fa7d9493SBabu Moger for (i = r->cache.cbm_len - 1; i >= 0; i--) { 963fa7d9493SBabu Moger pseudo_locked = dom->plr ? dom->plr->cbm : 0; 96432f010deSReinette Chatre hwb = test_bit(i, &hw_shareable); 96532f010deSReinette Chatre swb = test_bit(i, &sw_shareable); 96632f010deSReinette Chatre excl = test_bit(i, &exclusive); 96732f010deSReinette Chatre psl = test_bit(i, &pseudo_locked); 968fa7d9493SBabu Moger if (hwb && swb) 969fa7d9493SBabu Moger seq_putc(seq, 'X'); 970fa7d9493SBabu Moger else if (hwb && !swb) 971fa7d9493SBabu Moger seq_putc(seq, 'H'); 972fa7d9493SBabu Moger else if (!hwb && swb) 973fa7d9493SBabu Moger seq_putc(seq, 'S'); 974fa7d9493SBabu Moger else if (excl) 975fa7d9493SBabu Moger seq_putc(seq, 'E'); 976fa7d9493SBabu Moger else if (psl) 977fa7d9493SBabu Moger seq_putc(seq, 'P'); 978fa7d9493SBabu Moger else /* Unused bits remain */ 979fa7d9493SBabu Moger seq_putc(seq, '0'); 980fa7d9493SBabu Moger } 981fa7d9493SBabu Moger sep = true; 982fa7d9493SBabu Moger } 983fa7d9493SBabu Moger seq_putc(seq, '\n'); 984fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 985fa7d9493SBabu Moger return 0; 986fa7d9493SBabu Moger } 987fa7d9493SBabu Moger 988fa7d9493SBabu Moger static int rdt_min_bw_show(struct kernfs_open_file *of, 989fa7d9493SBabu Moger struct seq_file *seq, void *v) 990fa7d9493SBabu Moger { 991f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 992f2594492SJames Morse struct rdt_resource *r = s->res; 993fa7d9493SBabu Moger 994fa7d9493SBabu Moger seq_printf(seq, "%u\n", r->membw.min_bw); 995fa7d9493SBabu Moger return 0; 996fa7d9493SBabu Moger } 997fa7d9493SBabu Moger 998fa7d9493SBabu Moger static int rdt_num_rmids_show(struct kernfs_open_file *of, 999fa7d9493SBabu Moger struct seq_file *seq, void *v) 1000fa7d9493SBabu Moger { 1001fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 1002fa7d9493SBabu Moger 1003fa7d9493SBabu Moger seq_printf(seq, "%d\n", r->num_rmid); 1004fa7d9493SBabu Moger 1005fa7d9493SBabu Moger return 0; 1006fa7d9493SBabu Moger } 1007fa7d9493SBabu Moger 1008fa7d9493SBabu Moger static int rdt_mon_features_show(struct kernfs_open_file *of, 1009fa7d9493SBabu Moger struct seq_file *seq, void *v) 1010fa7d9493SBabu Moger { 1011fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 1012fa7d9493SBabu Moger struct mon_evt *mevt; 1013fa7d9493SBabu Moger 1014d507f83cSBabu Moger list_for_each_entry(mevt, &r->evt_list, list) { 1015fa7d9493SBabu Moger seq_printf(seq, "%s\n", mevt->name); 1016d507f83cSBabu Moger if (mevt->configurable) 1017d507f83cSBabu Moger seq_printf(seq, "%s_config\n", mevt->name); 1018d507f83cSBabu Moger } 1019fa7d9493SBabu Moger 1020fa7d9493SBabu Moger return 0; 1021fa7d9493SBabu Moger } 1022fa7d9493SBabu Moger 1023fa7d9493SBabu Moger static int rdt_bw_gran_show(struct kernfs_open_file *of, 1024fa7d9493SBabu Moger struct seq_file *seq, void *v) 1025fa7d9493SBabu Moger { 1026f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 1027f2594492SJames Morse struct rdt_resource *r = s->res; 1028fa7d9493SBabu Moger 1029fa7d9493SBabu Moger seq_printf(seq, "%u\n", r->membw.bw_gran); 1030fa7d9493SBabu Moger return 0; 1031fa7d9493SBabu Moger } 1032fa7d9493SBabu Moger 1033fa7d9493SBabu Moger static int rdt_delay_linear_show(struct kernfs_open_file *of, 1034fa7d9493SBabu Moger struct seq_file *seq, void *v) 1035fa7d9493SBabu Moger { 1036f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 1037f2594492SJames Morse struct rdt_resource *r = s->res; 1038fa7d9493SBabu Moger 1039fa7d9493SBabu Moger seq_printf(seq, "%u\n", r->membw.delay_linear); 1040fa7d9493SBabu Moger return 0; 1041fa7d9493SBabu Moger } 1042fa7d9493SBabu Moger 1043fa7d9493SBabu Moger static int max_threshold_occ_show(struct kernfs_open_file *of, 1044fa7d9493SBabu Moger struct seq_file *seq, void *v) 1045fa7d9493SBabu Moger { 1046ae2328b5SJames Morse seq_printf(seq, "%u\n", resctrl_rmid_realloc_threshold); 1047fa7d9493SBabu Moger 1048fa7d9493SBabu Moger return 0; 1049fa7d9493SBabu Moger } 1050fa7d9493SBabu Moger 105129b6bd41SFenghua Yu static int rdt_thread_throttle_mode_show(struct kernfs_open_file *of, 105229b6bd41SFenghua Yu struct seq_file *seq, void *v) 105329b6bd41SFenghua Yu { 1054f2594492SJames Morse struct resctrl_schema *s = of->kn->parent->priv; 1055f2594492SJames Morse struct rdt_resource *r = s->res; 105629b6bd41SFenghua Yu 105729b6bd41SFenghua Yu if (r->membw.throttle_mode == THREAD_THROTTLE_PER_THREAD) 105829b6bd41SFenghua Yu seq_puts(seq, "per-thread\n"); 105929b6bd41SFenghua Yu else 106029b6bd41SFenghua Yu seq_puts(seq, "max\n"); 106129b6bd41SFenghua Yu 106229b6bd41SFenghua Yu return 0; 106329b6bd41SFenghua Yu } 106429b6bd41SFenghua Yu 1065fa7d9493SBabu Moger static ssize_t max_threshold_occ_write(struct kernfs_open_file *of, 1066fa7d9493SBabu Moger char *buf, size_t nbytes, loff_t off) 1067fa7d9493SBabu Moger { 1068fa7d9493SBabu Moger unsigned int bytes; 1069fa7d9493SBabu Moger int ret; 1070fa7d9493SBabu Moger 1071fa7d9493SBabu Moger ret = kstrtouint(buf, 0, &bytes); 1072fa7d9493SBabu Moger if (ret) 1073fa7d9493SBabu Moger return ret; 1074fa7d9493SBabu Moger 1075d80975e2SJames Morse if (bytes > resctrl_rmid_realloc_limit) 1076fa7d9493SBabu Moger return -EINVAL; 1077fa7d9493SBabu Moger 1078ae2328b5SJames Morse resctrl_rmid_realloc_threshold = resctrl_arch_round_mon_val(bytes); 1079fa7d9493SBabu Moger 1080fa7d9493SBabu Moger return nbytes; 1081fa7d9493SBabu Moger } 1082fa7d9493SBabu Moger 1083fa7d9493SBabu Moger /* 1084fa7d9493SBabu Moger * rdtgroup_mode_show - Display mode of this resource group 1085fa7d9493SBabu Moger */ 1086fa7d9493SBabu Moger static int rdtgroup_mode_show(struct kernfs_open_file *of, 1087fa7d9493SBabu Moger struct seq_file *s, void *v) 1088fa7d9493SBabu Moger { 1089fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 1090fa7d9493SBabu Moger 1091fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 1092fa7d9493SBabu Moger if (!rdtgrp) { 1093fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1094fa7d9493SBabu Moger return -ENOENT; 1095fa7d9493SBabu Moger } 1096fa7d9493SBabu Moger 1097fa7d9493SBabu Moger seq_printf(s, "%s\n", rdtgroup_mode_str(rdtgrp->mode)); 1098fa7d9493SBabu Moger 1099fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1100fa7d9493SBabu Moger return 0; 1101fa7d9493SBabu Moger } 1102fa7d9493SBabu Moger 1103fbc06c69SJames Morse static enum resctrl_conf_type resctrl_peer_type(enum resctrl_conf_type my_type) 1104fa7d9493SBabu Moger { 1105fbc06c69SJames Morse switch (my_type) { 1106fbc06c69SJames Morse case CDP_CODE: 1107fbc06c69SJames Morse return CDP_DATA; 1108fbc06c69SJames Morse case CDP_DATA: 1109fbc06c69SJames Morse return CDP_CODE; 1110fa7d9493SBabu Moger default: 1111fbc06c69SJames Morse case CDP_NONE: 1112fbc06c69SJames Morse return CDP_NONE; 1113fa7d9493SBabu Moger } 1114fa7d9493SBabu Moger } 1115fa7d9493SBabu Moger 1116fa7d9493SBabu Moger /** 1117fa7d9493SBabu Moger * __rdtgroup_cbm_overlaps - Does CBM for intended closid overlap with other 1118fa7d9493SBabu Moger * @r: Resource to which domain instance @d belongs. 1119fa7d9493SBabu Moger * @d: The domain instance for which @closid is being tested. 1120fa7d9493SBabu Moger * @cbm: Capacity bitmask being tested. 1121fa7d9493SBabu Moger * @closid: Intended closid for @cbm. 1122fa7d9493SBabu Moger * @exclusive: Only check if overlaps with exclusive resource groups 1123fa7d9493SBabu Moger * 1124fa7d9493SBabu Moger * Checks if provided @cbm intended to be used for @closid on domain 1125fa7d9493SBabu Moger * @d overlaps with any other closids or other hardware usage associated 1126fa7d9493SBabu Moger * with this domain. If @exclusive is true then only overlaps with 1127fa7d9493SBabu Moger * resource groups in exclusive mode will be considered. If @exclusive 1128fa7d9493SBabu Moger * is false then overlaps with any resource group or hardware entities 1129fa7d9493SBabu Moger * will be considered. 1130fa7d9493SBabu Moger * 1131fa7d9493SBabu Moger * @cbm is unsigned long, even if only 32 bits are used, to make the 1132fa7d9493SBabu Moger * bitmap functions work correctly. 1133fa7d9493SBabu Moger * 1134fa7d9493SBabu Moger * Return: false if CBM does not overlap, true if it does. 1135fa7d9493SBabu Moger */ 1136fa7d9493SBabu Moger static bool __rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d, 1137fa8f711dSJames Morse unsigned long cbm, int closid, 1138fa8f711dSJames Morse enum resctrl_conf_type type, bool exclusive) 1139fa7d9493SBabu Moger { 1140fa7d9493SBabu Moger enum rdtgrp_mode mode; 1141fa7d9493SBabu Moger unsigned long ctrl_b; 1142fa7d9493SBabu Moger int i; 1143fa7d9493SBabu Moger 1144fa7d9493SBabu Moger /* Check for any overlap with regions used by hardware directly */ 1145fa7d9493SBabu Moger if (!exclusive) { 1146fa7d9493SBabu Moger ctrl_b = r->cache.shareable_bits; 1147fa7d9493SBabu Moger if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) 1148fa7d9493SBabu Moger return true; 1149fa7d9493SBabu Moger } 1150fa7d9493SBabu Moger 1151fa7d9493SBabu Moger /* Check for overlap with other resource groups */ 1152f07e9d02SJames Morse for (i = 0; i < closids_supported(); i++) { 1153111136e6SJames Morse ctrl_b = resctrl_arch_get_config(r, d, i, type); 1154fa7d9493SBabu Moger mode = rdtgroup_mode_by_closid(i); 1155fa7d9493SBabu Moger if (closid_allocated(i) && i != closid && 1156fa7d9493SBabu Moger mode != RDT_MODE_PSEUDO_LOCKSETUP) { 1157fa7d9493SBabu Moger if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) { 1158fa7d9493SBabu Moger if (exclusive) { 1159fa7d9493SBabu Moger if (mode == RDT_MODE_EXCLUSIVE) 1160fa7d9493SBabu Moger return true; 1161fa7d9493SBabu Moger continue; 1162fa7d9493SBabu Moger } 1163fa7d9493SBabu Moger return true; 1164fa7d9493SBabu Moger } 1165fa7d9493SBabu Moger } 1166fa7d9493SBabu Moger } 1167fa7d9493SBabu Moger 1168fa7d9493SBabu Moger return false; 1169fa7d9493SBabu Moger } 1170fa7d9493SBabu Moger 1171fa7d9493SBabu Moger /** 1172fa7d9493SBabu Moger * rdtgroup_cbm_overlaps - Does CBM overlap with other use of hardware 11731c290682SJames Morse * @s: Schema for the resource to which domain instance @d belongs. 1174fa7d9493SBabu Moger * @d: The domain instance for which @closid is being tested. 1175fa7d9493SBabu Moger * @cbm: Capacity bitmask being tested. 1176fa7d9493SBabu Moger * @closid: Intended closid for @cbm. 1177fa7d9493SBabu Moger * @exclusive: Only check if overlaps with exclusive resource groups 1178fa7d9493SBabu Moger * 1179fa7d9493SBabu Moger * Resources that can be allocated using a CBM can use the CBM to control 1180fa7d9493SBabu Moger * the overlap of these allocations. rdtgroup_cmb_overlaps() is the test 1181fa7d9493SBabu Moger * for overlap. Overlap test is not limited to the specific resource for 1182fa7d9493SBabu Moger * which the CBM is intended though - when dealing with CDP resources that 1183fa7d9493SBabu Moger * share the underlying hardware the overlap check should be performed on 1184fa7d9493SBabu Moger * the CDP resource sharing the hardware also. 1185fa7d9493SBabu Moger * 1186fa7d9493SBabu Moger * Refer to description of __rdtgroup_cbm_overlaps() for the details of the 1187fa7d9493SBabu Moger * overlap test. 1188fa7d9493SBabu Moger * 1189fa7d9493SBabu Moger * Return: true if CBM overlap detected, false if there is no overlap 1190fa7d9493SBabu Moger */ 11911c290682SJames Morse bool rdtgroup_cbm_overlaps(struct resctrl_schema *s, struct rdt_domain *d, 1192fa7d9493SBabu Moger unsigned long cbm, int closid, bool exclusive) 1193fa7d9493SBabu Moger { 1194fbc06c69SJames Morse enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 11951c290682SJames Morse struct rdt_resource *r = s->res; 1196fa7d9493SBabu Moger 1197fa8f711dSJames Morse if (__rdtgroup_cbm_overlaps(r, d, cbm, closid, s->conf_type, 1198fa8f711dSJames Morse exclusive)) 1199fa7d9493SBabu Moger return true; 1200fa7d9493SBabu Moger 1201fbc06c69SJames Morse if (!resctrl_arch_get_cdp_enabled(r->rid)) 1202fa7d9493SBabu Moger return false; 1203fbc06c69SJames Morse return __rdtgroup_cbm_overlaps(r, d, cbm, closid, peer_type, exclusive); 1204fa7d9493SBabu Moger } 1205fa7d9493SBabu Moger 1206fa7d9493SBabu Moger /** 1207fa7d9493SBabu Moger * rdtgroup_mode_test_exclusive - Test if this resource group can be exclusive 1208fa7d9493SBabu Moger * 1209fa7d9493SBabu Moger * An exclusive resource group implies that there should be no sharing of 1210fa7d9493SBabu Moger * its allocated resources. At the time this group is considered to be 1211fa7d9493SBabu Moger * exclusive this test can determine if its current schemata supports this 1212fa7d9493SBabu Moger * setting by testing for overlap with all other resource groups. 1213fa7d9493SBabu Moger * 1214fa7d9493SBabu Moger * Return: true if resource group can be exclusive, false if there is overlap 1215fa7d9493SBabu Moger * with allocations of other resource groups and thus this resource group 1216fa7d9493SBabu Moger * cannot be exclusive. 1217fa7d9493SBabu Moger */ 1218fa7d9493SBabu Moger static bool rdtgroup_mode_test_exclusive(struct rdtgroup *rdtgrp) 1219fa7d9493SBabu Moger { 1220fa7d9493SBabu Moger int closid = rdtgrp->closid; 1221331ebe4cSJames Morse struct resctrl_schema *s; 1222fa7d9493SBabu Moger struct rdt_resource *r; 1223fa7d9493SBabu Moger bool has_cache = false; 1224fa7d9493SBabu Moger struct rdt_domain *d; 1225f07e9d02SJames Morse u32 ctrl; 1226fa7d9493SBabu Moger 1227331ebe4cSJames Morse list_for_each_entry(s, &resctrl_schema_all, list) { 1228331ebe4cSJames Morse r = s->res; 12295b6fac3fSBabu Moger if (r->rid == RDT_RESOURCE_MBA || r->rid == RDT_RESOURCE_SMBA) 1230fa7d9493SBabu Moger continue; 1231fa7d9493SBabu Moger has_cache = true; 1232fa7d9493SBabu Moger list_for_each_entry(d, &r->domains, list) { 1233111136e6SJames Morse ctrl = resctrl_arch_get_config(r, d, closid, 1234111136e6SJames Morse s->conf_type); 1235f07e9d02SJames Morse if (rdtgroup_cbm_overlaps(s, d, ctrl, closid, false)) { 1236723f1a0dSBabu Moger rdt_last_cmd_puts("Schemata overlaps\n"); 1237fa7d9493SBabu Moger return false; 1238fa7d9493SBabu Moger } 1239fa7d9493SBabu Moger } 1240fa7d9493SBabu Moger } 1241fa7d9493SBabu Moger 1242fa7d9493SBabu Moger if (!has_cache) { 1243723f1a0dSBabu Moger rdt_last_cmd_puts("Cannot be exclusive without CAT/CDP\n"); 1244fa7d9493SBabu Moger return false; 1245fa7d9493SBabu Moger } 1246fa7d9493SBabu Moger 1247fa7d9493SBabu Moger return true; 1248fa7d9493SBabu Moger } 1249fa7d9493SBabu Moger 1250fa7d9493SBabu Moger /** 1251fa7d9493SBabu Moger * rdtgroup_mode_write - Modify the resource group's mode 1252fa7d9493SBabu Moger * 1253fa7d9493SBabu Moger */ 1254fa7d9493SBabu Moger static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, 1255fa7d9493SBabu Moger char *buf, size_t nbytes, loff_t off) 1256fa7d9493SBabu Moger { 1257fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 1258fa7d9493SBabu Moger enum rdtgrp_mode mode; 1259fa7d9493SBabu Moger int ret = 0; 1260fa7d9493SBabu Moger 1261fa7d9493SBabu Moger /* Valid input requires a trailing newline */ 1262fa7d9493SBabu Moger if (nbytes == 0 || buf[nbytes - 1] != '\n') 1263fa7d9493SBabu Moger return -EINVAL; 1264fa7d9493SBabu Moger buf[nbytes - 1] = '\0'; 1265fa7d9493SBabu Moger 1266fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 1267fa7d9493SBabu Moger if (!rdtgrp) { 1268fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1269fa7d9493SBabu Moger return -ENOENT; 1270fa7d9493SBabu Moger } 1271fa7d9493SBabu Moger 1272fa7d9493SBabu Moger rdt_last_cmd_clear(); 1273fa7d9493SBabu Moger 1274fa7d9493SBabu Moger mode = rdtgrp->mode; 1275fa7d9493SBabu Moger 1276fa7d9493SBabu Moger if ((!strcmp(buf, "shareable") && mode == RDT_MODE_SHAREABLE) || 1277fa7d9493SBabu Moger (!strcmp(buf, "exclusive") && mode == RDT_MODE_EXCLUSIVE) || 1278fa7d9493SBabu Moger (!strcmp(buf, "pseudo-locksetup") && 1279fa7d9493SBabu Moger mode == RDT_MODE_PSEUDO_LOCKSETUP) || 1280fa7d9493SBabu Moger (!strcmp(buf, "pseudo-locked") && mode == RDT_MODE_PSEUDO_LOCKED)) 1281fa7d9493SBabu Moger goto out; 1282fa7d9493SBabu Moger 1283fa7d9493SBabu Moger if (mode == RDT_MODE_PSEUDO_LOCKED) { 128445682489SReinette Chatre rdt_last_cmd_puts("Cannot change pseudo-locked group\n"); 1285fa7d9493SBabu Moger ret = -EINVAL; 1286fa7d9493SBabu Moger goto out; 1287fa7d9493SBabu Moger } 1288fa7d9493SBabu Moger 1289fa7d9493SBabu Moger if (!strcmp(buf, "shareable")) { 1290fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1291fa7d9493SBabu Moger ret = rdtgroup_locksetup_exit(rdtgrp); 1292fa7d9493SBabu Moger if (ret) 1293fa7d9493SBabu Moger goto out; 1294fa7d9493SBabu Moger } 1295fa7d9493SBabu Moger rdtgrp->mode = RDT_MODE_SHAREABLE; 1296fa7d9493SBabu Moger } else if (!strcmp(buf, "exclusive")) { 1297fa7d9493SBabu Moger if (!rdtgroup_mode_test_exclusive(rdtgrp)) { 1298fa7d9493SBabu Moger ret = -EINVAL; 1299fa7d9493SBabu Moger goto out; 1300fa7d9493SBabu Moger } 1301fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1302fa7d9493SBabu Moger ret = rdtgroup_locksetup_exit(rdtgrp); 1303fa7d9493SBabu Moger if (ret) 1304fa7d9493SBabu Moger goto out; 1305fa7d9493SBabu Moger } 1306fa7d9493SBabu Moger rdtgrp->mode = RDT_MODE_EXCLUSIVE; 1307fa7d9493SBabu Moger } else if (!strcmp(buf, "pseudo-locksetup")) { 1308fa7d9493SBabu Moger ret = rdtgroup_locksetup_enter(rdtgrp); 1309fa7d9493SBabu Moger if (ret) 1310fa7d9493SBabu Moger goto out; 1311fa7d9493SBabu Moger rdtgrp->mode = RDT_MODE_PSEUDO_LOCKSETUP; 1312fa7d9493SBabu Moger } else { 131345682489SReinette Chatre rdt_last_cmd_puts("Unknown or unsupported mode\n"); 1314fa7d9493SBabu Moger ret = -EINVAL; 1315fa7d9493SBabu Moger } 1316fa7d9493SBabu Moger 1317fa7d9493SBabu Moger out: 1318fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1319fa7d9493SBabu Moger return ret ?: nbytes; 1320fa7d9493SBabu Moger } 1321fa7d9493SBabu Moger 1322fa7d9493SBabu Moger /** 1323fa7d9493SBabu Moger * rdtgroup_cbm_to_size - Translate CBM to size in bytes 1324fa7d9493SBabu Moger * @r: RDT resource to which @d belongs. 1325fa7d9493SBabu Moger * @d: RDT domain instance. 1326fa7d9493SBabu Moger * @cbm: bitmask for which the size should be computed. 1327fa7d9493SBabu Moger * 1328fa7d9493SBabu Moger * The bitmask provided associated with the RDT domain instance @d will be 1329fa7d9493SBabu Moger * translated into how many bytes it represents. The size in bytes is 1330fa7d9493SBabu Moger * computed by first dividing the total cache size by the CBM length to 1331fa7d9493SBabu Moger * determine how many bytes each bit in the bitmask represents. The result 1332fa7d9493SBabu Moger * is multiplied with the number of bits set in the bitmask. 1333fa7d9493SBabu Moger * 1334fa7d9493SBabu Moger * @cbm is unsigned long, even if only 32 bits are used to make the 1335fa7d9493SBabu Moger * bitmap functions work correctly. 1336fa7d9493SBabu Moger */ 1337fa7d9493SBabu Moger unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, 1338fa7d9493SBabu Moger struct rdt_domain *d, unsigned long cbm) 1339fa7d9493SBabu Moger { 1340fa7d9493SBabu Moger struct cpu_cacheinfo *ci; 1341fa7d9493SBabu Moger unsigned int size = 0; 1342fa7d9493SBabu Moger int num_b, i; 1343fa7d9493SBabu Moger 1344fa7d9493SBabu Moger num_b = bitmap_weight(&cbm, r->cache.cbm_len); 1345fa7d9493SBabu Moger ci = get_cpu_cacheinfo(cpumask_any(&d->cpu_mask)); 1346fa7d9493SBabu Moger for (i = 0; i < ci->num_leaves; i++) { 1347fa7d9493SBabu Moger if (ci->info_list[i].level == r->cache_level) { 1348fa7d9493SBabu Moger size = ci->info_list[i].size / r->cache.cbm_len * num_b; 1349fa7d9493SBabu Moger break; 1350fa7d9493SBabu Moger } 1351fa7d9493SBabu Moger } 1352fa7d9493SBabu Moger 1353fa7d9493SBabu Moger return size; 1354fa7d9493SBabu Moger } 1355fa7d9493SBabu Moger 1356fa7d9493SBabu Moger /** 1357fa7d9493SBabu Moger * rdtgroup_size_show - Display size in bytes of allocated regions 1358fa7d9493SBabu Moger * 1359fa7d9493SBabu Moger * The "size" file mirrors the layout of the "schemata" file, printing the 1360fa7d9493SBabu Moger * size in bytes of each region instead of the capacity bitmask. 1361fa7d9493SBabu Moger * 1362fa7d9493SBabu Moger */ 1363fa7d9493SBabu Moger static int rdtgroup_size_show(struct kernfs_open_file *of, 1364fa7d9493SBabu Moger struct seq_file *s, void *v) 1365fa7d9493SBabu Moger { 1366331ebe4cSJames Morse struct resctrl_schema *schema; 13676ce1560dSJames Morse enum resctrl_conf_type type; 1368fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 1369fa7d9493SBabu Moger struct rdt_resource *r; 1370fa7d9493SBabu Moger struct rdt_domain *d; 1371fa7d9493SBabu Moger unsigned int size; 1372fa7d9493SBabu Moger int ret = 0; 13736ce1560dSJames Morse u32 closid; 1374fa7d9493SBabu Moger bool sep; 1375fa7d9493SBabu Moger u32 ctrl; 1376fa7d9493SBabu Moger 1377fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 1378fa7d9493SBabu Moger if (!rdtgrp) { 1379fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1380fa7d9493SBabu Moger return -ENOENT; 1381fa7d9493SBabu Moger } 1382fa7d9493SBabu Moger 1383fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 1384fa7d9493SBabu Moger if (!rdtgrp->plr->d) { 1385fa7d9493SBabu Moger rdt_last_cmd_clear(); 1386fa7d9493SBabu Moger rdt_last_cmd_puts("Cache domain offline\n"); 1387fa7d9493SBabu Moger ret = -ENODEV; 1388fa7d9493SBabu Moger } else { 1389fa7d9493SBabu Moger seq_printf(s, "%*s:", max_name_width, 1390e198fde3SJames Morse rdtgrp->plr->s->name); 139132150eddSJames Morse size = rdtgroup_cbm_to_size(rdtgrp->plr->s->res, 1392fa7d9493SBabu Moger rdtgrp->plr->d, 1393fa7d9493SBabu Moger rdtgrp->plr->cbm); 1394fa7d9493SBabu Moger seq_printf(s, "%d=%u\n", rdtgrp->plr->d->id, size); 1395fa7d9493SBabu Moger } 1396fa7d9493SBabu Moger goto out; 1397fa7d9493SBabu Moger } 1398fa7d9493SBabu Moger 13996ce1560dSJames Morse closid = rdtgrp->closid; 14006ce1560dSJames Morse 1401331ebe4cSJames Morse list_for_each_entry(schema, &resctrl_schema_all, list) { 1402331ebe4cSJames Morse r = schema->res; 14036ce1560dSJames Morse type = schema->conf_type; 1404fa7d9493SBabu Moger sep = false; 1405e198fde3SJames Morse seq_printf(s, "%*s:", max_name_width, schema->name); 1406fa7d9493SBabu Moger list_for_each_entry(d, &r->domains, list) { 1407fa7d9493SBabu Moger if (sep) 1408fa7d9493SBabu Moger seq_putc(s, ';'); 1409fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1410fa7d9493SBabu Moger size = 0; 1411fa7d9493SBabu Moger } else { 14126ce1560dSJames Morse if (is_mba_sc(r)) 14136ce1560dSJames Morse ctrl = d->mbps_val[closid]; 14146ce1560dSJames Morse else 1415111136e6SJames Morse ctrl = resctrl_arch_get_config(r, d, 14166ce1560dSJames Morse closid, 14176ce1560dSJames Morse type); 14185b6fac3fSBabu Moger if (r->rid == RDT_RESOURCE_MBA || 14195b6fac3fSBabu Moger r->rid == RDT_RESOURCE_SMBA) 1420fa7d9493SBabu Moger size = ctrl; 1421fa7d9493SBabu Moger else 1422fa7d9493SBabu Moger size = rdtgroup_cbm_to_size(r, d, ctrl); 1423fa7d9493SBabu Moger } 1424fa7d9493SBabu Moger seq_printf(s, "%d=%u", d->id, size); 1425fa7d9493SBabu Moger sep = true; 1426fa7d9493SBabu Moger } 1427fa7d9493SBabu Moger seq_putc(s, '\n'); 1428fa7d9493SBabu Moger } 1429fa7d9493SBabu Moger 1430fa7d9493SBabu Moger out: 1431fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1432fa7d9493SBabu Moger 1433fa7d9493SBabu Moger return ret; 1434fa7d9493SBabu Moger } 1435fa7d9493SBabu Moger 1436dc2a3e85SBabu Moger struct mon_config_info { 1437dc2a3e85SBabu Moger u32 evtid; 1438dc2a3e85SBabu Moger u32 mon_config; 1439dc2a3e85SBabu Moger }; 1440dc2a3e85SBabu Moger 1441dc2a3e85SBabu Moger #define INVALID_CONFIG_INDEX UINT_MAX 1442dc2a3e85SBabu Moger 1443dc2a3e85SBabu Moger /** 1444dc2a3e85SBabu Moger * mon_event_config_index_get - get the hardware index for the 1445dc2a3e85SBabu Moger * configurable event 1446dc2a3e85SBabu Moger * @evtid: event id. 1447dc2a3e85SBabu Moger * 1448dc2a3e85SBabu Moger * Return: 0 for evtid == QOS_L3_MBM_TOTAL_EVENT_ID 1449dc2a3e85SBabu Moger * 1 for evtid == QOS_L3_MBM_LOCAL_EVENT_ID 1450dc2a3e85SBabu Moger * INVALID_CONFIG_INDEX for invalid evtid 1451dc2a3e85SBabu Moger */ 1452dc2a3e85SBabu Moger static inline unsigned int mon_event_config_index_get(u32 evtid) 1453dc2a3e85SBabu Moger { 1454dc2a3e85SBabu Moger switch (evtid) { 1455dc2a3e85SBabu Moger case QOS_L3_MBM_TOTAL_EVENT_ID: 1456dc2a3e85SBabu Moger return 0; 1457dc2a3e85SBabu Moger case QOS_L3_MBM_LOCAL_EVENT_ID: 1458dc2a3e85SBabu Moger return 1; 1459dc2a3e85SBabu Moger default: 1460dc2a3e85SBabu Moger /* Should never reach here */ 1461dc2a3e85SBabu Moger return INVALID_CONFIG_INDEX; 1462dc2a3e85SBabu Moger } 1463dc2a3e85SBabu Moger } 1464dc2a3e85SBabu Moger 1465dc2a3e85SBabu Moger static void mon_event_config_read(void *info) 1466dc2a3e85SBabu Moger { 1467dc2a3e85SBabu Moger struct mon_config_info *mon_info = info; 1468dc2a3e85SBabu Moger unsigned int index; 1469793207baSBorislav Petkov (AMD) u64 msrval; 1470dc2a3e85SBabu Moger 1471dc2a3e85SBabu Moger index = mon_event_config_index_get(mon_info->evtid); 1472dc2a3e85SBabu Moger if (index == INVALID_CONFIG_INDEX) { 1473dc2a3e85SBabu Moger pr_warn_once("Invalid event id %d\n", mon_info->evtid); 1474dc2a3e85SBabu Moger return; 1475dc2a3e85SBabu Moger } 1476793207baSBorislav Petkov (AMD) rdmsrl(MSR_IA32_EVT_CFG_BASE + index, msrval); 1477dc2a3e85SBabu Moger 1478dc2a3e85SBabu Moger /* Report only the valid event configuration bits */ 1479793207baSBorislav Petkov (AMD) mon_info->mon_config = msrval & MAX_EVT_CONFIG_BITS; 1480dc2a3e85SBabu Moger } 1481dc2a3e85SBabu Moger 1482dc2a3e85SBabu Moger static void mondata_config_read(struct rdt_domain *d, struct mon_config_info *mon_info) 1483dc2a3e85SBabu Moger { 1484dc2a3e85SBabu Moger smp_call_function_any(&d->cpu_mask, mon_event_config_read, mon_info, 1); 1485dc2a3e85SBabu Moger } 1486dc2a3e85SBabu Moger 1487dc2a3e85SBabu Moger static int mbm_config_show(struct seq_file *s, struct rdt_resource *r, u32 evtid) 1488dc2a3e85SBabu Moger { 1489dc2a3e85SBabu Moger struct mon_config_info mon_info = {0}; 1490dc2a3e85SBabu Moger struct rdt_domain *dom; 1491dc2a3e85SBabu Moger bool sep = false; 1492dc2a3e85SBabu Moger 1493dc2a3e85SBabu Moger mutex_lock(&rdtgroup_mutex); 1494dc2a3e85SBabu Moger 1495dc2a3e85SBabu Moger list_for_each_entry(dom, &r->domains, list) { 1496dc2a3e85SBabu Moger if (sep) 1497dc2a3e85SBabu Moger seq_puts(s, ";"); 1498dc2a3e85SBabu Moger 1499dc2a3e85SBabu Moger memset(&mon_info, 0, sizeof(struct mon_config_info)); 1500dc2a3e85SBabu Moger mon_info.evtid = evtid; 1501dc2a3e85SBabu Moger mondata_config_read(dom, &mon_info); 1502dc2a3e85SBabu Moger 1503dc2a3e85SBabu Moger seq_printf(s, "%d=0x%02x", dom->id, mon_info.mon_config); 1504dc2a3e85SBabu Moger sep = true; 1505dc2a3e85SBabu Moger } 1506dc2a3e85SBabu Moger seq_puts(s, "\n"); 1507dc2a3e85SBabu Moger 1508dc2a3e85SBabu Moger mutex_unlock(&rdtgroup_mutex); 1509dc2a3e85SBabu Moger 1510dc2a3e85SBabu Moger return 0; 1511dc2a3e85SBabu Moger } 1512dc2a3e85SBabu Moger 1513dc2a3e85SBabu Moger static int mbm_total_bytes_config_show(struct kernfs_open_file *of, 1514dc2a3e85SBabu Moger struct seq_file *seq, void *v) 1515dc2a3e85SBabu Moger { 1516dc2a3e85SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 1517dc2a3e85SBabu Moger 1518dc2a3e85SBabu Moger mbm_config_show(seq, r, QOS_L3_MBM_TOTAL_EVENT_ID); 1519dc2a3e85SBabu Moger 1520dc2a3e85SBabu Moger return 0; 1521dc2a3e85SBabu Moger } 1522dc2a3e85SBabu Moger 152373afb2d3SBabu Moger static int mbm_local_bytes_config_show(struct kernfs_open_file *of, 152473afb2d3SBabu Moger struct seq_file *seq, void *v) 152573afb2d3SBabu Moger { 152673afb2d3SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 152773afb2d3SBabu Moger 152873afb2d3SBabu Moger mbm_config_show(seq, r, QOS_L3_MBM_LOCAL_EVENT_ID); 152973afb2d3SBabu Moger 153073afb2d3SBabu Moger return 0; 153173afb2d3SBabu Moger } 153273afb2d3SBabu Moger 153392bd5a13SBabu Moger static void mon_event_config_write(void *info) 153492bd5a13SBabu Moger { 153592bd5a13SBabu Moger struct mon_config_info *mon_info = info; 153692bd5a13SBabu Moger unsigned int index; 153792bd5a13SBabu Moger 153892bd5a13SBabu Moger index = mon_event_config_index_get(mon_info->evtid); 153992bd5a13SBabu Moger if (index == INVALID_CONFIG_INDEX) { 154092bd5a13SBabu Moger pr_warn_once("Invalid event id %d\n", mon_info->evtid); 154192bd5a13SBabu Moger return; 154292bd5a13SBabu Moger } 154392bd5a13SBabu Moger wrmsr(MSR_IA32_EVT_CFG_BASE + index, mon_info->mon_config, 0); 154492bd5a13SBabu Moger } 154592bd5a13SBabu Moger 154692bd5a13SBabu Moger static int mbm_config_write_domain(struct rdt_resource *r, 154792bd5a13SBabu Moger struct rdt_domain *d, u32 evtid, u32 val) 154892bd5a13SBabu Moger { 154992bd5a13SBabu Moger struct mon_config_info mon_info = {0}; 155092bd5a13SBabu Moger int ret = 0; 155192bd5a13SBabu Moger 155292bd5a13SBabu Moger /* mon_config cannot be more than the supported set of events */ 155392bd5a13SBabu Moger if (val > MAX_EVT_CONFIG_BITS) { 155492bd5a13SBabu Moger rdt_last_cmd_puts("Invalid event configuration\n"); 155592bd5a13SBabu Moger return -EINVAL; 155692bd5a13SBabu Moger } 155792bd5a13SBabu Moger 155892bd5a13SBabu Moger /* 155992bd5a13SBabu Moger * Read the current config value first. If both are the same then 156092bd5a13SBabu Moger * no need to write it again. 156192bd5a13SBabu Moger */ 156292bd5a13SBabu Moger mon_info.evtid = evtid; 156392bd5a13SBabu Moger mondata_config_read(d, &mon_info); 156492bd5a13SBabu Moger if (mon_info.mon_config == val) 156592bd5a13SBabu Moger goto out; 156692bd5a13SBabu Moger 156792bd5a13SBabu Moger mon_info.mon_config = val; 156892bd5a13SBabu Moger 156992bd5a13SBabu Moger /* 157092bd5a13SBabu Moger * Update MSR_IA32_EVT_CFG_BASE MSR on one of the CPUs in the 157192bd5a13SBabu Moger * domain. The MSRs offset from MSR MSR_IA32_EVT_CFG_BASE 157292bd5a13SBabu Moger * are scoped at the domain level. Writing any of these MSRs 157392bd5a13SBabu Moger * on one CPU is observed by all the CPUs in the domain. 157492bd5a13SBabu Moger */ 157592bd5a13SBabu Moger smp_call_function_any(&d->cpu_mask, mon_event_config_write, 157692bd5a13SBabu Moger &mon_info, 1); 157792bd5a13SBabu Moger 157892bd5a13SBabu Moger /* 157992bd5a13SBabu Moger * When an Event Configuration is changed, the bandwidth counters 158092bd5a13SBabu Moger * for all RMIDs and Events will be cleared by the hardware. The 158192bd5a13SBabu Moger * hardware also sets MSR_IA32_QM_CTR.Unavailable (bit 62) for 158292bd5a13SBabu Moger * every RMID on the next read to any event for every RMID. 158392bd5a13SBabu Moger * Subsequent reads will have MSR_IA32_QM_CTR.Unavailable (bit 62) 158492bd5a13SBabu Moger * cleared while it is tracked by the hardware. Clear the 158592bd5a13SBabu Moger * mbm_local and mbm_total counts for all the RMIDs. 158692bd5a13SBabu Moger */ 158792bd5a13SBabu Moger resctrl_arch_reset_rmid_all(r, d); 158892bd5a13SBabu Moger 158992bd5a13SBabu Moger out: 159092bd5a13SBabu Moger return ret; 159192bd5a13SBabu Moger } 159292bd5a13SBabu Moger 159392bd5a13SBabu Moger static int mon_config_write(struct rdt_resource *r, char *tok, u32 evtid) 159492bd5a13SBabu Moger { 159592bd5a13SBabu Moger char *dom_str = NULL, *id_str; 159692bd5a13SBabu Moger unsigned long dom_id, val; 159792bd5a13SBabu Moger struct rdt_domain *d; 159892bd5a13SBabu Moger int ret = 0; 159992bd5a13SBabu Moger 160092bd5a13SBabu Moger next: 160192bd5a13SBabu Moger if (!tok || tok[0] == '\0') 160292bd5a13SBabu Moger return 0; 160392bd5a13SBabu Moger 160492bd5a13SBabu Moger /* Start processing the strings for each domain */ 160592bd5a13SBabu Moger dom_str = strim(strsep(&tok, ";")); 160692bd5a13SBabu Moger id_str = strsep(&dom_str, "="); 160792bd5a13SBabu Moger 160892bd5a13SBabu Moger if (!id_str || kstrtoul(id_str, 10, &dom_id)) { 160992bd5a13SBabu Moger rdt_last_cmd_puts("Missing '=' or non-numeric domain id\n"); 161092bd5a13SBabu Moger return -EINVAL; 161192bd5a13SBabu Moger } 161292bd5a13SBabu Moger 161392bd5a13SBabu Moger if (!dom_str || kstrtoul(dom_str, 16, &val)) { 161492bd5a13SBabu Moger rdt_last_cmd_puts("Non-numeric event configuration value\n"); 161592bd5a13SBabu Moger return -EINVAL; 161692bd5a13SBabu Moger } 161792bd5a13SBabu Moger 161892bd5a13SBabu Moger list_for_each_entry(d, &r->domains, list) { 161992bd5a13SBabu Moger if (d->id == dom_id) { 162092bd5a13SBabu Moger ret = mbm_config_write_domain(r, d, evtid, val); 162192bd5a13SBabu Moger if (ret) 162292bd5a13SBabu Moger return -EINVAL; 162392bd5a13SBabu Moger goto next; 162492bd5a13SBabu Moger } 162592bd5a13SBabu Moger } 162692bd5a13SBabu Moger 162792bd5a13SBabu Moger return -EINVAL; 162892bd5a13SBabu Moger } 162992bd5a13SBabu Moger 163092bd5a13SBabu Moger static ssize_t mbm_total_bytes_config_write(struct kernfs_open_file *of, 163192bd5a13SBabu Moger char *buf, size_t nbytes, 163292bd5a13SBabu Moger loff_t off) 163392bd5a13SBabu Moger { 163492bd5a13SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 163592bd5a13SBabu Moger int ret; 163692bd5a13SBabu Moger 163792bd5a13SBabu Moger /* Valid input requires a trailing newline */ 163892bd5a13SBabu Moger if (nbytes == 0 || buf[nbytes - 1] != '\n') 163992bd5a13SBabu Moger return -EINVAL; 164092bd5a13SBabu Moger 164192bd5a13SBabu Moger mutex_lock(&rdtgroup_mutex); 164292bd5a13SBabu Moger 164392bd5a13SBabu Moger rdt_last_cmd_clear(); 164492bd5a13SBabu Moger 164592bd5a13SBabu Moger buf[nbytes - 1] = '\0'; 164692bd5a13SBabu Moger 164792bd5a13SBabu Moger ret = mon_config_write(r, buf, QOS_L3_MBM_TOTAL_EVENT_ID); 164892bd5a13SBabu Moger 164992bd5a13SBabu Moger mutex_unlock(&rdtgroup_mutex); 165092bd5a13SBabu Moger 165192bd5a13SBabu Moger return ret ?: nbytes; 165292bd5a13SBabu Moger } 165392bd5a13SBabu Moger 16544fe61bffSBabu Moger static ssize_t mbm_local_bytes_config_write(struct kernfs_open_file *of, 16554fe61bffSBabu Moger char *buf, size_t nbytes, 16564fe61bffSBabu Moger loff_t off) 16574fe61bffSBabu Moger { 16584fe61bffSBabu Moger struct rdt_resource *r = of->kn->parent->priv; 16594fe61bffSBabu Moger int ret; 16604fe61bffSBabu Moger 16614fe61bffSBabu Moger /* Valid input requires a trailing newline */ 16624fe61bffSBabu Moger if (nbytes == 0 || buf[nbytes - 1] != '\n') 16634fe61bffSBabu Moger return -EINVAL; 16644fe61bffSBabu Moger 16654fe61bffSBabu Moger mutex_lock(&rdtgroup_mutex); 16664fe61bffSBabu Moger 16674fe61bffSBabu Moger rdt_last_cmd_clear(); 16684fe61bffSBabu Moger 16694fe61bffSBabu Moger buf[nbytes - 1] = '\0'; 16704fe61bffSBabu Moger 16714fe61bffSBabu Moger ret = mon_config_write(r, buf, QOS_L3_MBM_LOCAL_EVENT_ID); 16724fe61bffSBabu Moger 16734fe61bffSBabu Moger mutex_unlock(&rdtgroup_mutex); 16744fe61bffSBabu Moger 16754fe61bffSBabu Moger return ret ?: nbytes; 16764fe61bffSBabu Moger } 16774fe61bffSBabu Moger 1678fa7d9493SBabu Moger /* rdtgroup information files for one cache resource. */ 1679fa7d9493SBabu Moger static struct rftype res_common_files[] = { 1680fa7d9493SBabu Moger { 1681fa7d9493SBabu Moger .name = "last_cmd_status", 1682fa7d9493SBabu Moger .mode = 0444, 1683fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1684fa7d9493SBabu Moger .seq_show = rdt_last_cmd_status_show, 1685fa7d9493SBabu Moger .fflags = RF_TOP_INFO, 1686fa7d9493SBabu Moger }, 1687fa7d9493SBabu Moger { 1688fa7d9493SBabu Moger .name = "num_closids", 1689fa7d9493SBabu Moger .mode = 0444, 1690fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1691fa7d9493SBabu Moger .seq_show = rdt_num_closids_show, 1692fa7d9493SBabu Moger .fflags = RF_CTRL_INFO, 1693fa7d9493SBabu Moger }, 1694fa7d9493SBabu Moger { 1695fa7d9493SBabu Moger .name = "mon_features", 1696fa7d9493SBabu Moger .mode = 0444, 1697fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1698fa7d9493SBabu Moger .seq_show = rdt_mon_features_show, 1699fa7d9493SBabu Moger .fflags = RF_MON_INFO, 1700fa7d9493SBabu Moger }, 1701fa7d9493SBabu Moger { 1702fa7d9493SBabu Moger .name = "num_rmids", 1703fa7d9493SBabu Moger .mode = 0444, 1704fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1705fa7d9493SBabu Moger .seq_show = rdt_num_rmids_show, 1706fa7d9493SBabu Moger .fflags = RF_MON_INFO, 1707fa7d9493SBabu Moger }, 1708fa7d9493SBabu Moger { 1709fa7d9493SBabu Moger .name = "cbm_mask", 1710fa7d9493SBabu Moger .mode = 0444, 1711fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1712fa7d9493SBabu Moger .seq_show = rdt_default_ctrl_show, 1713fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1714fa7d9493SBabu Moger }, 1715fa7d9493SBabu Moger { 1716fa7d9493SBabu Moger .name = "min_cbm_bits", 1717fa7d9493SBabu Moger .mode = 0444, 1718fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1719fa7d9493SBabu Moger .seq_show = rdt_min_cbm_bits_show, 1720fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1721fa7d9493SBabu Moger }, 1722fa7d9493SBabu Moger { 1723fa7d9493SBabu Moger .name = "shareable_bits", 1724fa7d9493SBabu Moger .mode = 0444, 1725fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1726fa7d9493SBabu Moger .seq_show = rdt_shareable_bits_show, 1727fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1728fa7d9493SBabu Moger }, 1729fa7d9493SBabu Moger { 1730fa7d9493SBabu Moger .name = "bit_usage", 1731fa7d9493SBabu Moger .mode = 0444, 1732fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1733fa7d9493SBabu Moger .seq_show = rdt_bit_usage_show, 1734fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1735fa7d9493SBabu Moger }, 1736fa7d9493SBabu Moger { 1737fa7d9493SBabu Moger .name = "min_bandwidth", 1738fa7d9493SBabu Moger .mode = 0444, 1739fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1740fa7d9493SBabu Moger .seq_show = rdt_min_bw_show, 1741fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1742fa7d9493SBabu Moger }, 1743fa7d9493SBabu Moger { 1744fa7d9493SBabu Moger .name = "bandwidth_gran", 1745fa7d9493SBabu Moger .mode = 0444, 1746fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1747fa7d9493SBabu Moger .seq_show = rdt_bw_gran_show, 1748fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1749fa7d9493SBabu Moger }, 1750fa7d9493SBabu Moger { 1751fa7d9493SBabu Moger .name = "delay_linear", 1752fa7d9493SBabu Moger .mode = 0444, 1753fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1754fa7d9493SBabu Moger .seq_show = rdt_delay_linear_show, 1755fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1756fa7d9493SBabu Moger }, 175729b6bd41SFenghua Yu /* 175829b6bd41SFenghua Yu * Platform specific which (if any) capabilities are provided by 175929b6bd41SFenghua Yu * thread_throttle_mode. Defer "fflags" initialization to platform 176029b6bd41SFenghua Yu * discovery. 176129b6bd41SFenghua Yu */ 176229b6bd41SFenghua Yu { 176329b6bd41SFenghua Yu .name = "thread_throttle_mode", 176429b6bd41SFenghua Yu .mode = 0444, 176529b6bd41SFenghua Yu .kf_ops = &rdtgroup_kf_single_ops, 176629b6bd41SFenghua Yu .seq_show = rdt_thread_throttle_mode_show, 176729b6bd41SFenghua Yu }, 1768fa7d9493SBabu Moger { 1769fa7d9493SBabu Moger .name = "max_threshold_occupancy", 1770fa7d9493SBabu Moger .mode = 0644, 1771fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1772fa7d9493SBabu Moger .write = max_threshold_occ_write, 1773fa7d9493SBabu Moger .seq_show = max_threshold_occ_show, 1774fa7d9493SBabu Moger .fflags = RF_MON_INFO | RFTYPE_RES_CACHE, 1775fa7d9493SBabu Moger }, 1776fa7d9493SBabu Moger { 1777dc2a3e85SBabu Moger .name = "mbm_total_bytes_config", 177892bd5a13SBabu Moger .mode = 0644, 1779dc2a3e85SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1780dc2a3e85SBabu Moger .seq_show = mbm_total_bytes_config_show, 178192bd5a13SBabu Moger .write = mbm_total_bytes_config_write, 1782dc2a3e85SBabu Moger }, 1783dc2a3e85SBabu Moger { 178473afb2d3SBabu Moger .name = "mbm_local_bytes_config", 17854fe61bffSBabu Moger .mode = 0644, 178673afb2d3SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 178773afb2d3SBabu Moger .seq_show = mbm_local_bytes_config_show, 17884fe61bffSBabu Moger .write = mbm_local_bytes_config_write, 178973afb2d3SBabu Moger }, 179073afb2d3SBabu Moger { 1791fa7d9493SBabu Moger .name = "cpus", 1792fa7d9493SBabu Moger .mode = 0644, 1793fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1794fa7d9493SBabu Moger .write = rdtgroup_cpus_write, 1795fa7d9493SBabu Moger .seq_show = rdtgroup_cpus_show, 1796fa7d9493SBabu Moger .fflags = RFTYPE_BASE, 1797fa7d9493SBabu Moger }, 1798fa7d9493SBabu Moger { 1799fa7d9493SBabu Moger .name = "cpus_list", 1800fa7d9493SBabu Moger .mode = 0644, 1801fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1802fa7d9493SBabu Moger .write = rdtgroup_cpus_write, 1803fa7d9493SBabu Moger .seq_show = rdtgroup_cpus_show, 1804fa7d9493SBabu Moger .flags = RFTYPE_FLAGS_CPUS_LIST, 1805fa7d9493SBabu Moger .fflags = RFTYPE_BASE, 1806fa7d9493SBabu Moger }, 1807fa7d9493SBabu Moger { 1808fa7d9493SBabu Moger .name = "tasks", 1809fa7d9493SBabu Moger .mode = 0644, 1810fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1811fa7d9493SBabu Moger .write = rdtgroup_tasks_write, 1812fa7d9493SBabu Moger .seq_show = rdtgroup_tasks_show, 1813fa7d9493SBabu Moger .fflags = RFTYPE_BASE, 1814fa7d9493SBabu Moger }, 1815fa7d9493SBabu Moger { 1816fa7d9493SBabu Moger .name = "schemata", 1817fa7d9493SBabu Moger .mode = 0644, 1818fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1819fa7d9493SBabu Moger .write = rdtgroup_schemata_write, 1820fa7d9493SBabu Moger .seq_show = rdtgroup_schemata_show, 1821fa7d9493SBabu Moger .fflags = RF_CTRL_BASE, 1822fa7d9493SBabu Moger }, 1823fa7d9493SBabu Moger { 1824fa7d9493SBabu Moger .name = "mode", 1825fa7d9493SBabu Moger .mode = 0644, 1826fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1827fa7d9493SBabu Moger .write = rdtgroup_mode_write, 1828fa7d9493SBabu Moger .seq_show = rdtgroup_mode_show, 1829fa7d9493SBabu Moger .fflags = RF_CTRL_BASE, 1830fa7d9493SBabu Moger }, 1831fa7d9493SBabu Moger { 1832fa7d9493SBabu Moger .name = "size", 1833fa7d9493SBabu Moger .mode = 0444, 1834fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1835fa7d9493SBabu Moger .seq_show = rdtgroup_size_show, 1836fa7d9493SBabu Moger .fflags = RF_CTRL_BASE, 1837fa7d9493SBabu Moger }, 1838fa7d9493SBabu Moger 1839fa7d9493SBabu Moger }; 1840fa7d9493SBabu Moger 1841fa7d9493SBabu Moger static int rdtgroup_add_files(struct kernfs_node *kn, unsigned long fflags) 1842fa7d9493SBabu Moger { 1843fa7d9493SBabu Moger struct rftype *rfts, *rft; 1844fa7d9493SBabu Moger int ret, len; 1845fa7d9493SBabu Moger 1846fa7d9493SBabu Moger rfts = res_common_files; 1847fa7d9493SBabu Moger len = ARRAY_SIZE(res_common_files); 1848fa7d9493SBabu Moger 1849fa7d9493SBabu Moger lockdep_assert_held(&rdtgroup_mutex); 1850fa7d9493SBabu Moger 1851fa7d9493SBabu Moger for (rft = rfts; rft < rfts + len; rft++) { 185229b6bd41SFenghua Yu if (rft->fflags && ((fflags & rft->fflags) == rft->fflags)) { 1853fa7d9493SBabu Moger ret = rdtgroup_add_file(kn, rft); 1854fa7d9493SBabu Moger if (ret) 1855fa7d9493SBabu Moger goto error; 1856fa7d9493SBabu Moger } 1857fa7d9493SBabu Moger } 1858fa7d9493SBabu Moger 1859fa7d9493SBabu Moger return 0; 1860fa7d9493SBabu Moger error: 1861fa7d9493SBabu Moger pr_warn("Failed to add %s, err=%d\n", rft->name, ret); 1862fa7d9493SBabu Moger while (--rft >= rfts) { 1863fa7d9493SBabu Moger if ((fflags & rft->fflags) == rft->fflags) 1864fa7d9493SBabu Moger kernfs_remove_by_name(kn, rft->name); 1865fa7d9493SBabu Moger } 1866fa7d9493SBabu Moger return ret; 1867fa7d9493SBabu Moger } 1868fa7d9493SBabu Moger 186929b6bd41SFenghua Yu static struct rftype *rdtgroup_get_rftype_by_name(const char *name) 187029b6bd41SFenghua Yu { 187129b6bd41SFenghua Yu struct rftype *rfts, *rft; 187229b6bd41SFenghua Yu int len; 187329b6bd41SFenghua Yu 187429b6bd41SFenghua Yu rfts = res_common_files; 187529b6bd41SFenghua Yu len = ARRAY_SIZE(res_common_files); 187629b6bd41SFenghua Yu 187729b6bd41SFenghua Yu for (rft = rfts; rft < rfts + len; rft++) { 187829b6bd41SFenghua Yu if (!strcmp(rft->name, name)) 187929b6bd41SFenghua Yu return rft; 188029b6bd41SFenghua Yu } 188129b6bd41SFenghua Yu 188229b6bd41SFenghua Yu return NULL; 188329b6bd41SFenghua Yu } 188429b6bd41SFenghua Yu 188529b6bd41SFenghua Yu void __init thread_throttle_mode_init(void) 188629b6bd41SFenghua Yu { 188729b6bd41SFenghua Yu struct rftype *rft; 188829b6bd41SFenghua Yu 188929b6bd41SFenghua Yu rft = rdtgroup_get_rftype_by_name("thread_throttle_mode"); 189029b6bd41SFenghua Yu if (!rft) 189129b6bd41SFenghua Yu return; 189229b6bd41SFenghua Yu 189329b6bd41SFenghua Yu rft->fflags = RF_CTRL_INFO | RFTYPE_RES_MB; 189429b6bd41SFenghua Yu } 189529b6bd41SFenghua Yu 1896dc2a3e85SBabu Moger void __init mbm_config_rftype_init(const char *config) 1897dc2a3e85SBabu Moger { 1898dc2a3e85SBabu Moger struct rftype *rft; 1899dc2a3e85SBabu Moger 1900dc2a3e85SBabu Moger rft = rdtgroup_get_rftype_by_name(config); 1901dc2a3e85SBabu Moger if (rft) 1902dc2a3e85SBabu Moger rft->fflags = RF_MON_INFO | RFTYPE_RES_CACHE; 1903dc2a3e85SBabu Moger } 1904dc2a3e85SBabu Moger 1905fa7d9493SBabu Moger /** 1906fa7d9493SBabu Moger * rdtgroup_kn_mode_restrict - Restrict user access to named resctrl file 1907fa7d9493SBabu Moger * @r: The resource group with which the file is associated. 1908fa7d9493SBabu Moger * @name: Name of the file 1909fa7d9493SBabu Moger * 1910fa7d9493SBabu Moger * The permissions of named resctrl file, directory, or link are modified 1911fa7d9493SBabu Moger * to not allow read, write, or execute by any user. 1912fa7d9493SBabu Moger * 1913fa7d9493SBabu Moger * WARNING: This function is intended to communicate to the user that the 1914fa7d9493SBabu Moger * resctrl file has been locked down - that it is not relevant to the 1915fa7d9493SBabu Moger * particular state the system finds itself in. It should not be relied 1916fa7d9493SBabu Moger * on to protect from user access because after the file's permissions 1917fa7d9493SBabu Moger * are restricted the user can still change the permissions using chmod 1918fa7d9493SBabu Moger * from the command line. 1919fa7d9493SBabu Moger * 1920fa7d9493SBabu Moger * Return: 0 on success, <0 on failure. 1921fa7d9493SBabu Moger */ 1922fa7d9493SBabu Moger int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name) 1923fa7d9493SBabu Moger { 1924fa7d9493SBabu Moger struct iattr iattr = {.ia_valid = ATTR_MODE,}; 1925fa7d9493SBabu Moger struct kernfs_node *kn; 1926fa7d9493SBabu Moger int ret = 0; 1927fa7d9493SBabu Moger 1928fa7d9493SBabu Moger kn = kernfs_find_and_get_ns(r->kn, name, NULL); 1929fa7d9493SBabu Moger if (!kn) 1930fa7d9493SBabu Moger return -ENOENT; 1931fa7d9493SBabu Moger 1932fa7d9493SBabu Moger switch (kernfs_type(kn)) { 1933fa7d9493SBabu Moger case KERNFS_DIR: 1934fa7d9493SBabu Moger iattr.ia_mode = S_IFDIR; 1935fa7d9493SBabu Moger break; 1936fa7d9493SBabu Moger case KERNFS_FILE: 1937fa7d9493SBabu Moger iattr.ia_mode = S_IFREG; 1938fa7d9493SBabu Moger break; 1939fa7d9493SBabu Moger case KERNFS_LINK: 1940fa7d9493SBabu Moger iattr.ia_mode = S_IFLNK; 1941fa7d9493SBabu Moger break; 1942fa7d9493SBabu Moger } 1943fa7d9493SBabu Moger 1944fa7d9493SBabu Moger ret = kernfs_setattr(kn, &iattr); 1945fa7d9493SBabu Moger kernfs_put(kn); 1946fa7d9493SBabu Moger return ret; 1947fa7d9493SBabu Moger } 1948fa7d9493SBabu Moger 1949fa7d9493SBabu Moger /** 1950fa7d9493SBabu Moger * rdtgroup_kn_mode_restore - Restore user access to named resctrl file 1951fa7d9493SBabu Moger * @r: The resource group with which the file is associated. 1952fa7d9493SBabu Moger * @name: Name of the file 1953fa7d9493SBabu Moger * @mask: Mask of permissions that should be restored 1954fa7d9493SBabu Moger * 1955fa7d9493SBabu Moger * Restore the permissions of the named file. If @name is a directory the 1956fa7d9493SBabu Moger * permissions of its parent will be used. 1957fa7d9493SBabu Moger * 1958fa7d9493SBabu Moger * Return: 0 on success, <0 on failure. 1959fa7d9493SBabu Moger */ 1960fa7d9493SBabu Moger int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, 1961fa7d9493SBabu Moger umode_t mask) 1962fa7d9493SBabu Moger { 1963fa7d9493SBabu Moger struct iattr iattr = {.ia_valid = ATTR_MODE,}; 1964fa7d9493SBabu Moger struct kernfs_node *kn, *parent; 1965fa7d9493SBabu Moger struct rftype *rfts, *rft; 1966fa7d9493SBabu Moger int ret, len; 1967fa7d9493SBabu Moger 1968fa7d9493SBabu Moger rfts = res_common_files; 1969fa7d9493SBabu Moger len = ARRAY_SIZE(res_common_files); 1970fa7d9493SBabu Moger 1971fa7d9493SBabu Moger for (rft = rfts; rft < rfts + len; rft++) { 1972fa7d9493SBabu Moger if (!strcmp(rft->name, name)) 1973fa7d9493SBabu Moger iattr.ia_mode = rft->mode & mask; 1974fa7d9493SBabu Moger } 1975fa7d9493SBabu Moger 1976fa7d9493SBabu Moger kn = kernfs_find_and_get_ns(r->kn, name, NULL); 1977fa7d9493SBabu Moger if (!kn) 1978fa7d9493SBabu Moger return -ENOENT; 1979fa7d9493SBabu Moger 1980fa7d9493SBabu Moger switch (kernfs_type(kn)) { 1981fa7d9493SBabu Moger case KERNFS_DIR: 1982fa7d9493SBabu Moger parent = kernfs_get_parent(kn); 1983fa7d9493SBabu Moger if (parent) { 1984fa7d9493SBabu Moger iattr.ia_mode |= parent->mode; 1985fa7d9493SBabu Moger kernfs_put(parent); 1986fa7d9493SBabu Moger } 1987fa7d9493SBabu Moger iattr.ia_mode |= S_IFDIR; 1988fa7d9493SBabu Moger break; 1989fa7d9493SBabu Moger case KERNFS_FILE: 1990fa7d9493SBabu Moger iattr.ia_mode |= S_IFREG; 1991fa7d9493SBabu Moger break; 1992fa7d9493SBabu Moger case KERNFS_LINK: 1993fa7d9493SBabu Moger iattr.ia_mode |= S_IFLNK; 1994fa7d9493SBabu Moger break; 1995fa7d9493SBabu Moger } 1996fa7d9493SBabu Moger 1997fa7d9493SBabu Moger ret = kernfs_setattr(kn, &iattr); 1998fa7d9493SBabu Moger kernfs_put(kn); 1999fa7d9493SBabu Moger return ret; 2000fa7d9493SBabu Moger } 2001fa7d9493SBabu Moger 2002f2594492SJames Morse static int rdtgroup_mkdir_info_resdir(void *priv, char *name, 2003fa7d9493SBabu Moger unsigned long fflags) 2004fa7d9493SBabu Moger { 2005fa7d9493SBabu Moger struct kernfs_node *kn_subdir; 2006fa7d9493SBabu Moger int ret; 2007fa7d9493SBabu Moger 2008fa7d9493SBabu Moger kn_subdir = kernfs_create_dir(kn_info, name, 2009f2594492SJames Morse kn_info->mode, priv); 2010fa7d9493SBabu Moger if (IS_ERR(kn_subdir)) 2011fa7d9493SBabu Moger return PTR_ERR(kn_subdir); 2012fa7d9493SBabu Moger 2013fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn_subdir); 2014fa7d9493SBabu Moger if (ret) 2015fa7d9493SBabu Moger return ret; 2016fa7d9493SBabu Moger 2017fa7d9493SBabu Moger ret = rdtgroup_add_files(kn_subdir, fflags); 2018fa7d9493SBabu Moger if (!ret) 2019fa7d9493SBabu Moger kernfs_activate(kn_subdir); 2020fa7d9493SBabu Moger 2021fa7d9493SBabu Moger return ret; 2022fa7d9493SBabu Moger } 2023fa7d9493SBabu Moger 2024fa7d9493SBabu Moger static int rdtgroup_create_info_dir(struct kernfs_node *parent_kn) 2025fa7d9493SBabu Moger { 2026f2594492SJames Morse struct resctrl_schema *s; 2027fa7d9493SBabu Moger struct rdt_resource *r; 2028fa7d9493SBabu Moger unsigned long fflags; 2029fa7d9493SBabu Moger char name[32]; 2030fa7d9493SBabu Moger int ret; 2031fa7d9493SBabu Moger 2032fa7d9493SBabu Moger /* create the directory */ 2033fa7d9493SBabu Moger kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL); 2034fa7d9493SBabu Moger if (IS_ERR(kn_info)) 2035fa7d9493SBabu Moger return PTR_ERR(kn_info); 2036fa7d9493SBabu Moger 2037fa7d9493SBabu Moger ret = rdtgroup_add_files(kn_info, RF_TOP_INFO); 2038fa7d9493SBabu Moger if (ret) 2039fa7d9493SBabu Moger goto out_destroy; 2040fa7d9493SBabu Moger 20414d269ed4SJames Morse /* loop over enabled controls, these are all alloc_capable */ 2042f2594492SJames Morse list_for_each_entry(s, &resctrl_schema_all, list) { 2043f2594492SJames Morse r = s->res; 2044fa7d9493SBabu Moger fflags = r->fflags | RF_CTRL_INFO; 2045e198fde3SJames Morse ret = rdtgroup_mkdir_info_resdir(s, s->name, fflags); 2046fa7d9493SBabu Moger if (ret) 2047fa7d9493SBabu Moger goto out_destroy; 2048fa7d9493SBabu Moger } 2049fa7d9493SBabu Moger 2050bab6ee73SJames Morse for_each_mon_capable_rdt_resource(r) { 2051fa7d9493SBabu Moger fflags = r->fflags | RF_MON_INFO; 2052fa7d9493SBabu Moger sprintf(name, "%s_MON", r->name); 2053fa7d9493SBabu Moger ret = rdtgroup_mkdir_info_resdir(r, name, fflags); 2054fa7d9493SBabu Moger if (ret) 2055fa7d9493SBabu Moger goto out_destroy; 2056fa7d9493SBabu Moger } 2057fa7d9493SBabu Moger 2058fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn_info); 2059fa7d9493SBabu Moger if (ret) 2060fa7d9493SBabu Moger goto out_destroy; 2061fa7d9493SBabu Moger 2062fa7d9493SBabu Moger kernfs_activate(kn_info); 2063fa7d9493SBabu Moger 2064fa7d9493SBabu Moger return 0; 2065fa7d9493SBabu Moger 2066fa7d9493SBabu Moger out_destroy: 2067fa7d9493SBabu Moger kernfs_remove(kn_info); 2068fa7d9493SBabu Moger return ret; 2069fa7d9493SBabu Moger } 2070fa7d9493SBabu Moger 2071fa7d9493SBabu Moger static int 2072fa7d9493SBabu Moger mongroup_create_dir(struct kernfs_node *parent_kn, struct rdtgroup *prgrp, 2073fa7d9493SBabu Moger char *name, struct kernfs_node **dest_kn) 2074fa7d9493SBabu Moger { 2075fa7d9493SBabu Moger struct kernfs_node *kn; 2076fa7d9493SBabu Moger int ret; 2077fa7d9493SBabu Moger 2078fa7d9493SBabu Moger /* create the directory */ 2079fa7d9493SBabu Moger kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 2080fa7d9493SBabu Moger if (IS_ERR(kn)) 2081fa7d9493SBabu Moger return PTR_ERR(kn); 2082fa7d9493SBabu Moger 2083fa7d9493SBabu Moger if (dest_kn) 2084fa7d9493SBabu Moger *dest_kn = kn; 2085fa7d9493SBabu Moger 2086fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 2087fa7d9493SBabu Moger if (ret) 2088fa7d9493SBabu Moger goto out_destroy; 2089fa7d9493SBabu Moger 2090fa7d9493SBabu Moger kernfs_activate(kn); 2091fa7d9493SBabu Moger 2092fa7d9493SBabu Moger return 0; 2093fa7d9493SBabu Moger 2094fa7d9493SBabu Moger out_destroy: 2095fa7d9493SBabu Moger kernfs_remove(kn); 2096fa7d9493SBabu Moger return ret; 2097fa7d9493SBabu Moger } 2098fa7d9493SBabu Moger 2099fa7d9493SBabu Moger static void l3_qos_cfg_update(void *arg) 2100fa7d9493SBabu Moger { 2101fa7d9493SBabu Moger bool *enable = arg; 2102fa7d9493SBabu Moger 2103aa50453aSBabu Moger wrmsrl(MSR_IA32_L3_QOS_CFG, *enable ? L3_QOS_CDP_ENABLE : 0ULL); 2104fa7d9493SBabu Moger } 2105fa7d9493SBabu Moger 2106fa7d9493SBabu Moger static void l2_qos_cfg_update(void *arg) 2107fa7d9493SBabu Moger { 2108fa7d9493SBabu Moger bool *enable = arg; 2109fa7d9493SBabu Moger 2110aa50453aSBabu Moger wrmsrl(MSR_IA32_L2_QOS_CFG, *enable ? L2_QOS_CDP_ENABLE : 0ULL); 2111fa7d9493SBabu Moger } 2112fa7d9493SBabu Moger 2113fa7d9493SBabu Moger static inline bool is_mba_linear(void) 2114fa7d9493SBabu Moger { 211563c8b123SJames Morse return rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl.membw.delay_linear; 2116fa7d9493SBabu Moger } 2117fa7d9493SBabu Moger 2118fa7d9493SBabu Moger static int set_cache_qos_cfg(int level, bool enable) 2119fa7d9493SBabu Moger { 2120fa7d9493SBabu Moger void (*update)(void *arg); 2121fa7d9493SBabu Moger struct rdt_resource *r_l; 2122fa7d9493SBabu Moger cpumask_var_t cpu_mask; 2123fa7d9493SBabu Moger struct rdt_domain *d; 2124fa7d9493SBabu Moger int cpu; 2125fa7d9493SBabu Moger 2126fa7d9493SBabu Moger if (level == RDT_RESOURCE_L3) 2127fa7d9493SBabu Moger update = l3_qos_cfg_update; 2128fa7d9493SBabu Moger else if (level == RDT_RESOURCE_L2) 2129fa7d9493SBabu Moger update = l2_qos_cfg_update; 2130fa7d9493SBabu Moger else 2131fa7d9493SBabu Moger return -EINVAL; 2132fa7d9493SBabu Moger 2133ab6a2114SShakeel Butt if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL)) 2134ab6a2114SShakeel Butt return -ENOMEM; 2135ab6a2114SShakeel Butt 213663c8b123SJames Morse r_l = &rdt_resources_all[level].r_resctrl; 2137fa7d9493SBabu Moger list_for_each_entry(d, &r_l->domains, list) { 2138fae3a13dSBabu Moger if (r_l->cache.arch_has_per_cpu_cfg) 2139fae3a13dSBabu Moger /* Pick all the CPUs in the domain instance */ 2140fae3a13dSBabu Moger for_each_cpu(cpu, &d->cpu_mask) 2141fae3a13dSBabu Moger cpumask_set_cpu(cpu, cpu_mask); 2142fae3a13dSBabu Moger else 2143fa7d9493SBabu Moger /* Pick one CPU from each domain instance to update MSR */ 2144fa7d9493SBabu Moger cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask); 2145fa7d9493SBabu Moger } 2146fc3b618cSBabu Moger 2147fc3b618cSBabu Moger /* Update QOS_CFG MSR on all the CPUs in cpu_mask */ 2148fc3b618cSBabu Moger on_each_cpu_mask(cpu_mask, update, &enable, 1); 2149fa7d9493SBabu Moger 2150fa7d9493SBabu Moger free_cpumask_var(cpu_mask); 2151fa7d9493SBabu Moger 2152fa7d9493SBabu Moger return 0; 2153fa7d9493SBabu Moger } 2154fa7d9493SBabu Moger 21559fe04507SJames Morse /* Restore the qos cfg state when a domain comes online */ 21569fe04507SJames Morse void rdt_domain_reconfigure_cdp(struct rdt_resource *r) 21579fe04507SJames Morse { 2158c091e907SJames Morse struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 2159c091e907SJames Morse 2160c091e907SJames Morse if (!r->cdp_capable) 21619fe04507SJames Morse return; 21629fe04507SJames Morse 21635c3b63cdSJames Morse if (r->rid == RDT_RESOURCE_L2) 2164c091e907SJames Morse l2_qos_cfg_update(&hw_res->cdp_enabled); 21659fe04507SJames Morse 21665c3b63cdSJames Morse if (r->rid == RDT_RESOURCE_L3) 2167c091e907SJames Morse l3_qos_cfg_update(&hw_res->cdp_enabled); 21689fe04507SJames Morse } 21699fe04507SJames Morse 2170781096d9SJames Morse static int mba_sc_domain_allocate(struct rdt_resource *r, struct rdt_domain *d) 2171781096d9SJames Morse { 2172781096d9SJames Morse u32 num_closid = resctrl_arch_get_num_closid(r); 2173781096d9SJames Morse int cpu = cpumask_any(&d->cpu_mask); 2174781096d9SJames Morse int i; 2175781096d9SJames Morse 2176781096d9SJames Morse d->mbps_val = kcalloc_node(num_closid, sizeof(*d->mbps_val), 2177781096d9SJames Morse GFP_KERNEL, cpu_to_node(cpu)); 2178781096d9SJames Morse if (!d->mbps_val) 2179781096d9SJames Morse return -ENOMEM; 2180781096d9SJames Morse 2181781096d9SJames Morse for (i = 0; i < num_closid; i++) 2182781096d9SJames Morse d->mbps_val[i] = MBA_MAX_MBPS; 2183781096d9SJames Morse 2184781096d9SJames Morse return 0; 2185781096d9SJames Morse } 2186781096d9SJames Morse 2187781096d9SJames Morse static void mba_sc_domain_destroy(struct rdt_resource *r, 2188781096d9SJames Morse struct rdt_domain *d) 2189781096d9SJames Morse { 2190781096d9SJames Morse kfree(d->mbps_val); 2191781096d9SJames Morse d->mbps_val = NULL; 2192781096d9SJames Morse } 2193781096d9SJames Morse 2194fa7d9493SBabu Moger /* 2195fa7d9493SBabu Moger * MBA software controller is supported only if 2196fa7d9493SBabu Moger * MBM is supported and MBA is in linear scale. 2197fa7d9493SBabu Moger */ 2198b045c215SJames Morse static bool supports_mba_mbps(void) 2199b045c215SJames Morse { 2200b045c215SJames Morse struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl; 2201b045c215SJames Morse 2202b045c215SJames Morse return (is_mbm_local_enabled() && 2203b045c215SJames Morse r->alloc_capable && is_mba_linear()); 2204b045c215SJames Morse } 2205b045c215SJames Morse 2206b045c215SJames Morse /* 2207b045c215SJames Morse * Enable or disable the MBA software controller 2208b045c215SJames Morse * which helps user specify bandwidth in MBps. 2209b045c215SJames Morse */ 2210fa7d9493SBabu Moger static int set_mba_sc(bool mba_sc) 2211fa7d9493SBabu Moger { 221263c8b123SJames Morse struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl; 2213781096d9SJames Morse u32 num_closid = resctrl_arch_get_num_closid(r); 2214781096d9SJames Morse struct rdt_domain *d; 2215781096d9SJames Morse int i; 2216fa7d9493SBabu Moger 2217b045c215SJames Morse if (!supports_mba_mbps() || mba_sc == is_mba_sc(r)) 2218fa7d9493SBabu Moger return -EINVAL; 2219fa7d9493SBabu Moger 2220fa7d9493SBabu Moger r->membw.mba_sc = mba_sc; 2221fa7d9493SBabu Moger 2222781096d9SJames Morse list_for_each_entry(d, &r->domains, list) { 2223781096d9SJames Morse for (i = 0; i < num_closid; i++) 2224781096d9SJames Morse d->mbps_val[i] = MBA_MAX_MBPS; 2225781096d9SJames Morse } 2226781096d9SJames Morse 2227fa7d9493SBabu Moger return 0; 2228fa7d9493SBabu Moger } 2229fa7d9493SBabu Moger 22305c3b63cdSJames Morse static int cdp_enable(int level) 2231fa7d9493SBabu Moger { 223263c8b123SJames Morse struct rdt_resource *r_l = &rdt_resources_all[level].r_resctrl; 2233fa7d9493SBabu Moger int ret; 2234fa7d9493SBabu Moger 22355c3b63cdSJames Morse if (!r_l->alloc_capable) 2236fa7d9493SBabu Moger return -EINVAL; 2237fa7d9493SBabu Moger 2238fa7d9493SBabu Moger ret = set_cache_qos_cfg(level, true); 22395c3b63cdSJames Morse if (!ret) 2240c091e907SJames Morse rdt_resources_all[level].cdp_enabled = true; 22415c3b63cdSJames Morse 2242fa7d9493SBabu Moger return ret; 2243fa7d9493SBabu Moger } 2244fa7d9493SBabu Moger 22455c3b63cdSJames Morse static void cdp_disable(int level) 2246fa7d9493SBabu Moger { 2247c091e907SJames Morse struct rdt_hw_resource *r_hw = &rdt_resources_all[level]; 2248fa7d9493SBabu Moger 2249c091e907SJames Morse if (r_hw->cdp_enabled) { 2250fa7d9493SBabu Moger set_cache_qos_cfg(level, false); 2251c091e907SJames Morse r_hw->cdp_enabled = false; 2252fa7d9493SBabu Moger } 2253fa7d9493SBabu Moger } 2254fa7d9493SBabu Moger 2255c091e907SJames Morse int resctrl_arch_set_cdp_enabled(enum resctrl_res_level l, bool enable) 2256fa7d9493SBabu Moger { 2257c091e907SJames Morse struct rdt_hw_resource *hw_res = &rdt_resources_all[l]; 2258c091e907SJames Morse 2259c091e907SJames Morse if (!hw_res->r_resctrl.cdp_capable) 2260c091e907SJames Morse return -EINVAL; 2261c091e907SJames Morse 2262c091e907SJames Morse if (enable) 22635c3b63cdSJames Morse return cdp_enable(l); 2264c091e907SJames Morse 22655c3b63cdSJames Morse cdp_disable(l); 2266c091e907SJames Morse 2267c091e907SJames Morse return 0; 2268fa7d9493SBabu Moger } 2269fa7d9493SBabu Moger 2270fa7d9493SBabu Moger static void cdp_disable_all(void) 2271fa7d9493SBabu Moger { 2272c091e907SJames Morse if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3)) 2273c091e907SJames Morse resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, false); 2274c091e907SJames Morse if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) 2275c091e907SJames Morse resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, false); 2276fa7d9493SBabu Moger } 2277fa7d9493SBabu Moger 2278fa7d9493SBabu Moger /* 2279fa7d9493SBabu Moger * We don't allow rdtgroup directories to be created anywhere 2280fa7d9493SBabu Moger * except the root directory. Thus when looking for the rdtgroup 2281fa7d9493SBabu Moger * structure for a kernfs node we are either looking at a directory, 2282fa7d9493SBabu Moger * in which case the rdtgroup structure is pointed at by the "priv" 2283fa7d9493SBabu Moger * field, otherwise we have a file, and need only look to the parent 2284fa7d9493SBabu Moger * to find the rdtgroup. 2285fa7d9493SBabu Moger */ 2286fa7d9493SBabu Moger static struct rdtgroup *kernfs_to_rdtgroup(struct kernfs_node *kn) 2287fa7d9493SBabu Moger { 2288fa7d9493SBabu Moger if (kernfs_type(kn) == KERNFS_DIR) { 2289fa7d9493SBabu Moger /* 2290fa7d9493SBabu Moger * All the resource directories use "kn->priv" 2291fa7d9493SBabu Moger * to point to the "struct rdtgroup" for the 2292fa7d9493SBabu Moger * resource. "info" and its subdirectories don't 2293fa7d9493SBabu Moger * have rdtgroup structures, so return NULL here. 2294fa7d9493SBabu Moger */ 2295fa7d9493SBabu Moger if (kn == kn_info || kn->parent == kn_info) 2296fa7d9493SBabu Moger return NULL; 2297fa7d9493SBabu Moger else 2298fa7d9493SBabu Moger return kn->priv; 2299fa7d9493SBabu Moger } else { 2300fa7d9493SBabu Moger return kn->parent->priv; 2301fa7d9493SBabu Moger } 2302fa7d9493SBabu Moger } 2303fa7d9493SBabu Moger 2304fa7d9493SBabu Moger struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn) 2305fa7d9493SBabu Moger { 2306fa7d9493SBabu Moger struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2307fa7d9493SBabu Moger 2308fa7d9493SBabu Moger if (!rdtgrp) 2309fa7d9493SBabu Moger return NULL; 2310fa7d9493SBabu Moger 2311fa7d9493SBabu Moger atomic_inc(&rdtgrp->waitcount); 2312fa7d9493SBabu Moger kernfs_break_active_protection(kn); 2313fa7d9493SBabu Moger 2314fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 2315fa7d9493SBabu Moger 2316fa7d9493SBabu Moger /* Was this group deleted while we waited? */ 2317fa7d9493SBabu Moger if (rdtgrp->flags & RDT_DELETED) 2318fa7d9493SBabu Moger return NULL; 2319fa7d9493SBabu Moger 2320fa7d9493SBabu Moger return rdtgrp; 2321fa7d9493SBabu Moger } 2322fa7d9493SBabu Moger 2323fa7d9493SBabu Moger void rdtgroup_kn_unlock(struct kernfs_node *kn) 2324fa7d9493SBabu Moger { 2325fa7d9493SBabu Moger struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2326fa7d9493SBabu Moger 2327fa7d9493SBabu Moger if (!rdtgrp) 2328fa7d9493SBabu Moger return; 2329fa7d9493SBabu Moger 2330fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 2331fa7d9493SBabu Moger 2332fa7d9493SBabu Moger if (atomic_dec_and_test(&rdtgrp->waitcount) && 2333fa7d9493SBabu Moger (rdtgrp->flags & RDT_DELETED)) { 2334fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2335fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2336fa7d9493SBabu Moger rdtgroup_pseudo_lock_remove(rdtgrp); 2337fa7d9493SBabu Moger kernfs_unbreak_active_protection(kn); 233875899924SXiaochen Shen rdtgroup_remove(rdtgrp); 2339fa7d9493SBabu Moger } else { 2340fa7d9493SBabu Moger kernfs_unbreak_active_protection(kn); 2341fa7d9493SBabu Moger } 2342fa7d9493SBabu Moger } 2343fa7d9493SBabu Moger 2344fa7d9493SBabu Moger static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2345fa7d9493SBabu Moger struct rdtgroup *prgrp, 2346fa7d9493SBabu Moger struct kernfs_node **mon_data_kn); 2347fa7d9493SBabu Moger 234823bf1b6bSDavid Howells static int rdt_enable_ctx(struct rdt_fs_context *ctx) 2349fa7d9493SBabu Moger { 235023bf1b6bSDavid Howells int ret = 0; 235123bf1b6bSDavid Howells 235223bf1b6bSDavid Howells if (ctx->enable_cdpl2) 2353c091e907SJames Morse ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, true); 235423bf1b6bSDavid Howells 235523bf1b6bSDavid Howells if (!ret && ctx->enable_cdpl3) 2356c091e907SJames Morse ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, true); 235723bf1b6bSDavid Howells 235823bf1b6bSDavid Howells if (!ret && ctx->enable_mba_mbps) 235923bf1b6bSDavid Howells ret = set_mba_sc(true); 236023bf1b6bSDavid Howells 236123bf1b6bSDavid Howells return ret; 236223bf1b6bSDavid Howells } 236323bf1b6bSDavid Howells 23645c3b63cdSJames Morse static int schemata_list_add(struct rdt_resource *r, enum resctrl_conf_type type) 2365cdb9ebc9SJames Morse { 2366cdb9ebc9SJames Morse struct resctrl_schema *s; 23675c3b63cdSJames Morse const char *suffix = ""; 2368e198fde3SJames Morse int ret, cl; 2369cdb9ebc9SJames Morse 2370cdb9ebc9SJames Morse s = kzalloc(sizeof(*s), GFP_KERNEL); 2371cdb9ebc9SJames Morse if (!s) 2372cdb9ebc9SJames Morse return -ENOMEM; 2373cdb9ebc9SJames Morse 2374cdb9ebc9SJames Morse s->res = r; 2375eb6f3187SJames Morse s->num_closid = resctrl_arch_get_num_closid(r); 2376141739aaSJames Morse if (resctrl_arch_get_cdp_enabled(r->rid)) 2377141739aaSJames Morse s->num_closid /= 2; 2378cdb9ebc9SJames Morse 23795c3b63cdSJames Morse s->conf_type = type; 23805c3b63cdSJames Morse switch (type) { 23815c3b63cdSJames Morse case CDP_CODE: 23825c3b63cdSJames Morse suffix = "CODE"; 23835c3b63cdSJames Morse break; 23845c3b63cdSJames Morse case CDP_DATA: 23855c3b63cdSJames Morse suffix = "DATA"; 23865c3b63cdSJames Morse break; 23875c3b63cdSJames Morse case CDP_NONE: 23885c3b63cdSJames Morse suffix = ""; 23895c3b63cdSJames Morse break; 23905c3b63cdSJames Morse } 23915c3b63cdSJames Morse 23925c3b63cdSJames Morse ret = snprintf(s->name, sizeof(s->name), "%s%s", r->name, suffix); 2393e198fde3SJames Morse if (ret >= sizeof(s->name)) { 2394e198fde3SJames Morse kfree(s); 2395e198fde3SJames Morse return -EINVAL; 2396e198fde3SJames Morse } 2397e198fde3SJames Morse 2398e198fde3SJames Morse cl = strlen(s->name); 2399e198fde3SJames Morse 2400e198fde3SJames Morse /* 2401e198fde3SJames Morse * If CDP is supported by this resource, but not enabled, 2402e198fde3SJames Morse * include the suffix. This ensures the tabular format of the 24035c3b63cdSJames Morse * schemata file does not change between mounts of the filesystem. 2404e198fde3SJames Morse */ 2405e198fde3SJames Morse if (r->cdp_capable && !resctrl_arch_get_cdp_enabled(r->rid)) 2406e198fde3SJames Morse cl += 4; 2407e198fde3SJames Morse 2408e198fde3SJames Morse if (cl > max_name_width) 2409e198fde3SJames Morse max_name_width = cl; 2410e198fde3SJames Morse 2411cdb9ebc9SJames Morse INIT_LIST_HEAD(&s->list); 2412cdb9ebc9SJames Morse list_add(&s->list, &resctrl_schema_all); 2413cdb9ebc9SJames Morse 2414cdb9ebc9SJames Morse return 0; 2415cdb9ebc9SJames Morse } 2416cdb9ebc9SJames Morse 24175c3b63cdSJames Morse static int schemata_list_create(void) 24185c3b63cdSJames Morse { 24195c3b63cdSJames Morse struct rdt_resource *r; 24205c3b63cdSJames Morse int ret = 0; 24215c3b63cdSJames Morse 24224d269ed4SJames Morse for_each_alloc_capable_rdt_resource(r) { 24235c3b63cdSJames Morse if (resctrl_arch_get_cdp_enabled(r->rid)) { 24245c3b63cdSJames Morse ret = schemata_list_add(r, CDP_CODE); 24255c3b63cdSJames Morse if (ret) 24265c3b63cdSJames Morse break; 24275c3b63cdSJames Morse 24285c3b63cdSJames Morse ret = schemata_list_add(r, CDP_DATA); 24295c3b63cdSJames Morse } else { 24305c3b63cdSJames Morse ret = schemata_list_add(r, CDP_NONE); 24315c3b63cdSJames Morse } 24325c3b63cdSJames Morse 24335c3b63cdSJames Morse if (ret) 24345c3b63cdSJames Morse break; 24355c3b63cdSJames Morse } 24365c3b63cdSJames Morse 24375c3b63cdSJames Morse return ret; 24385c3b63cdSJames Morse } 24395c3b63cdSJames Morse 2440cdb9ebc9SJames Morse static void schemata_list_destroy(void) 2441cdb9ebc9SJames Morse { 2442cdb9ebc9SJames Morse struct resctrl_schema *s, *tmp; 2443cdb9ebc9SJames Morse 2444cdb9ebc9SJames Morse list_for_each_entry_safe(s, tmp, &resctrl_schema_all, list) { 2445cdb9ebc9SJames Morse list_del(&s->list); 2446cdb9ebc9SJames Morse kfree(s); 2447cdb9ebc9SJames Morse } 2448cdb9ebc9SJames Morse } 2449cdb9ebc9SJames Morse 245023bf1b6bSDavid Howells static int rdt_get_tree(struct fs_context *fc) 245123bf1b6bSDavid Howells { 245223bf1b6bSDavid Howells struct rdt_fs_context *ctx = rdt_fc2context(fc); 2453fa7d9493SBabu Moger struct rdt_domain *dom; 2454fa7d9493SBabu Moger struct rdt_resource *r; 2455fa7d9493SBabu Moger int ret; 2456fa7d9493SBabu Moger 2457fa7d9493SBabu Moger cpus_read_lock(); 2458fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 2459fa7d9493SBabu Moger /* 2460fa7d9493SBabu Moger * resctrl file system can only be mounted once. 2461fa7d9493SBabu Moger */ 2462fa7d9493SBabu Moger if (static_branch_unlikely(&rdt_enable_key)) { 246323bf1b6bSDavid Howells ret = -EBUSY; 2464fa7d9493SBabu Moger goto out; 2465fa7d9493SBabu Moger } 2466fa7d9493SBabu Moger 246723bf1b6bSDavid Howells ret = rdt_enable_ctx(ctx); 246823bf1b6bSDavid Howells if (ret < 0) 2469fa7d9493SBabu Moger goto out_cdp; 2470fa7d9493SBabu Moger 2471cdb9ebc9SJames Morse ret = schemata_list_create(); 2472cdb9ebc9SJames Morse if (ret) { 2473cdb9ebc9SJames Morse schemata_list_destroy(); 2474cdb9ebc9SJames Morse goto out_mba; 2475cdb9ebc9SJames Morse } 2476cdb9ebc9SJames Morse 2477fa7d9493SBabu Moger closid_init(); 2478fa7d9493SBabu Moger 2479fa7d9493SBabu Moger ret = rdtgroup_create_info_dir(rdtgroup_default.kn); 248023bf1b6bSDavid Howells if (ret < 0) 2481cdb9ebc9SJames Morse goto out_schemata_free; 2482fa7d9493SBabu Moger 2483fa7d9493SBabu Moger if (rdt_mon_capable) { 2484fa7d9493SBabu Moger ret = mongroup_create_dir(rdtgroup_default.kn, 2485334b0f4eSXiaochen Shen &rdtgroup_default, "mon_groups", 2486fa7d9493SBabu Moger &kn_mongrp); 248723bf1b6bSDavid Howells if (ret < 0) 2488fa7d9493SBabu Moger goto out_info; 2489fa7d9493SBabu Moger 2490fa7d9493SBabu Moger ret = mkdir_mondata_all(rdtgroup_default.kn, 2491fa7d9493SBabu Moger &rdtgroup_default, &kn_mondata); 249223bf1b6bSDavid Howells if (ret < 0) 2493fa7d9493SBabu Moger goto out_mongrp; 2494fa7d9493SBabu Moger rdtgroup_default.mon.mon_data_kn = kn_mondata; 2495fa7d9493SBabu Moger } 2496fa7d9493SBabu Moger 2497fa7d9493SBabu Moger ret = rdt_pseudo_lock_init(); 249823bf1b6bSDavid Howells if (ret) 2499fa7d9493SBabu Moger goto out_mondata; 2500fa7d9493SBabu Moger 250123bf1b6bSDavid Howells ret = kernfs_get_tree(fc); 250223bf1b6bSDavid Howells if (ret < 0) 2503fa7d9493SBabu Moger goto out_psl; 2504fa7d9493SBabu Moger 2505fa7d9493SBabu Moger if (rdt_alloc_capable) 2506fa7d9493SBabu Moger static_branch_enable_cpuslocked(&rdt_alloc_enable_key); 2507fa7d9493SBabu Moger if (rdt_mon_capable) 2508fa7d9493SBabu Moger static_branch_enable_cpuslocked(&rdt_mon_enable_key); 2509fa7d9493SBabu Moger 2510fa7d9493SBabu Moger if (rdt_alloc_capable || rdt_mon_capable) 2511fa7d9493SBabu Moger static_branch_enable_cpuslocked(&rdt_enable_key); 2512fa7d9493SBabu Moger 2513fa7d9493SBabu Moger if (is_mbm_enabled()) { 251463c8b123SJames Morse r = &rdt_resources_all[RDT_RESOURCE_L3].r_resctrl; 2515fa7d9493SBabu Moger list_for_each_entry(dom, &r->domains, list) 2516fa7d9493SBabu Moger mbm_setup_overflow_handler(dom, MBM_OVERFLOW_INTERVAL); 2517fa7d9493SBabu Moger } 2518fa7d9493SBabu Moger 2519fa7d9493SBabu Moger goto out; 2520fa7d9493SBabu Moger 2521fa7d9493SBabu Moger out_psl: 2522fa7d9493SBabu Moger rdt_pseudo_lock_release(); 2523fa7d9493SBabu Moger out_mondata: 2524fa7d9493SBabu Moger if (rdt_mon_capable) 2525fa7d9493SBabu Moger kernfs_remove(kn_mondata); 2526fa7d9493SBabu Moger out_mongrp: 2527fa7d9493SBabu Moger if (rdt_mon_capable) 2528fa7d9493SBabu Moger kernfs_remove(kn_mongrp); 2529fa7d9493SBabu Moger out_info: 2530fa7d9493SBabu Moger kernfs_remove(kn_info); 2531cdb9ebc9SJames Morse out_schemata_free: 2532cdb9ebc9SJames Morse schemata_list_destroy(); 253323bf1b6bSDavid Howells out_mba: 253423bf1b6bSDavid Howells if (ctx->enable_mba_mbps) 253523bf1b6bSDavid Howells set_mba_sc(false); 2536fa7d9493SBabu Moger out_cdp: 2537fa7d9493SBabu Moger cdp_disable_all(); 2538fa7d9493SBabu Moger out: 2539fa7d9493SBabu Moger rdt_last_cmd_clear(); 2540fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 2541fa7d9493SBabu Moger cpus_read_unlock(); 254223bf1b6bSDavid Howells return ret; 254323bf1b6bSDavid Howells } 2544fa7d9493SBabu Moger 254523bf1b6bSDavid Howells enum rdt_param { 254623bf1b6bSDavid Howells Opt_cdp, 254723bf1b6bSDavid Howells Opt_cdpl2, 2548faa3604eSXiaochen Shen Opt_mba_mbps, 254923bf1b6bSDavid Howells nr__rdt_params 255023bf1b6bSDavid Howells }; 255123bf1b6bSDavid Howells 2552d7167b14SAl Viro static const struct fs_parameter_spec rdt_fs_parameters[] = { 255323bf1b6bSDavid Howells fsparam_flag("cdp", Opt_cdp), 255423bf1b6bSDavid Howells fsparam_flag("cdpl2", Opt_cdpl2), 2555faa3604eSXiaochen Shen fsparam_flag("mba_MBps", Opt_mba_mbps), 255623bf1b6bSDavid Howells {} 255723bf1b6bSDavid Howells }; 255823bf1b6bSDavid Howells 255923bf1b6bSDavid Howells static int rdt_parse_param(struct fs_context *fc, struct fs_parameter *param) 256023bf1b6bSDavid Howells { 256123bf1b6bSDavid Howells struct rdt_fs_context *ctx = rdt_fc2context(fc); 256223bf1b6bSDavid Howells struct fs_parse_result result; 256323bf1b6bSDavid Howells int opt; 256423bf1b6bSDavid Howells 2565d7167b14SAl Viro opt = fs_parse(fc, rdt_fs_parameters, param, &result); 256623bf1b6bSDavid Howells if (opt < 0) 256723bf1b6bSDavid Howells return opt; 256823bf1b6bSDavid Howells 256923bf1b6bSDavid Howells switch (opt) { 257023bf1b6bSDavid Howells case Opt_cdp: 257123bf1b6bSDavid Howells ctx->enable_cdpl3 = true; 257223bf1b6bSDavid Howells return 0; 257323bf1b6bSDavid Howells case Opt_cdpl2: 257423bf1b6bSDavid Howells ctx->enable_cdpl2 = true; 257523bf1b6bSDavid Howells return 0; 2576faa3604eSXiaochen Shen case Opt_mba_mbps: 2577b045c215SJames Morse if (!supports_mba_mbps()) 257823bf1b6bSDavid Howells return -EINVAL; 257923bf1b6bSDavid Howells ctx->enable_mba_mbps = true; 258023bf1b6bSDavid Howells return 0; 258123bf1b6bSDavid Howells } 258223bf1b6bSDavid Howells 258323bf1b6bSDavid Howells return -EINVAL; 258423bf1b6bSDavid Howells } 258523bf1b6bSDavid Howells 258623bf1b6bSDavid Howells static void rdt_fs_context_free(struct fs_context *fc) 258723bf1b6bSDavid Howells { 258823bf1b6bSDavid Howells struct rdt_fs_context *ctx = rdt_fc2context(fc); 258923bf1b6bSDavid Howells 259023bf1b6bSDavid Howells kernfs_free_fs_context(fc); 259123bf1b6bSDavid Howells kfree(ctx); 259223bf1b6bSDavid Howells } 259323bf1b6bSDavid Howells 259423bf1b6bSDavid Howells static const struct fs_context_operations rdt_fs_context_ops = { 259523bf1b6bSDavid Howells .free = rdt_fs_context_free, 259623bf1b6bSDavid Howells .parse_param = rdt_parse_param, 259723bf1b6bSDavid Howells .get_tree = rdt_get_tree, 259823bf1b6bSDavid Howells }; 259923bf1b6bSDavid Howells 260023bf1b6bSDavid Howells static int rdt_init_fs_context(struct fs_context *fc) 260123bf1b6bSDavid Howells { 260223bf1b6bSDavid Howells struct rdt_fs_context *ctx; 260323bf1b6bSDavid Howells 260423bf1b6bSDavid Howells ctx = kzalloc(sizeof(struct rdt_fs_context), GFP_KERNEL); 260523bf1b6bSDavid Howells if (!ctx) 260623bf1b6bSDavid Howells return -ENOMEM; 260723bf1b6bSDavid Howells 260823bf1b6bSDavid Howells ctx->kfc.root = rdt_root; 260923bf1b6bSDavid Howells ctx->kfc.magic = RDTGROUP_SUPER_MAGIC; 261023bf1b6bSDavid Howells fc->fs_private = &ctx->kfc; 261123bf1b6bSDavid Howells fc->ops = &rdt_fs_context_ops; 261223bf1b6bSDavid Howells put_user_ns(fc->user_ns); 261323bf1b6bSDavid Howells fc->user_ns = get_user_ns(&init_user_ns); 261423bf1b6bSDavid Howells fc->global = true; 261523bf1b6bSDavid Howells return 0; 2616fa7d9493SBabu Moger } 2617fa7d9493SBabu Moger 2618fa7d9493SBabu Moger static int reset_all_ctrls(struct rdt_resource *r) 2619fa7d9493SBabu Moger { 262063c8b123SJames Morse struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 2621792e0f6fSJames Morse struct rdt_hw_domain *hw_dom; 2622fa7d9493SBabu Moger struct msr_param msr_param; 2623fa7d9493SBabu Moger cpumask_var_t cpu_mask; 2624fa7d9493SBabu Moger struct rdt_domain *d; 2625fc3b618cSBabu Moger int i; 2626fa7d9493SBabu Moger 2627fa7d9493SBabu Moger if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL)) 2628fa7d9493SBabu Moger return -ENOMEM; 2629fa7d9493SBabu Moger 2630fa7d9493SBabu Moger msr_param.res = r; 2631fa7d9493SBabu Moger msr_param.low = 0; 263263c8b123SJames Morse msr_param.high = hw_res->num_closid; 2633fa7d9493SBabu Moger 2634fa7d9493SBabu Moger /* 2635fa7d9493SBabu Moger * Disable resource control for this resource by setting all 2636fa7d9493SBabu Moger * CBMs in all domains to the maximum mask value. Pick one CPU 2637fa7d9493SBabu Moger * from each domain to update the MSRs below. 2638fa7d9493SBabu Moger */ 2639fa7d9493SBabu Moger list_for_each_entry(d, &r->domains, list) { 2640792e0f6fSJames Morse hw_dom = resctrl_to_arch_dom(d); 2641fa7d9493SBabu Moger cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask); 2642fa7d9493SBabu Moger 2643b58d4eb1SJames Morse for (i = 0; i < hw_res->num_closid; i++) 2644792e0f6fSJames Morse hw_dom->ctrl_val[i] = r->default_ctrl; 2645fa7d9493SBabu Moger } 2646fc3b618cSBabu Moger 2647fc3b618cSBabu Moger /* Update CBM on all the CPUs in cpu_mask */ 2648fc3b618cSBabu Moger on_each_cpu_mask(cpu_mask, rdt_ctrl_update, &msr_param, 1); 2649fa7d9493SBabu Moger 2650fa7d9493SBabu Moger free_cpumask_var(cpu_mask); 2651fa7d9493SBabu Moger 2652fa7d9493SBabu Moger return 0; 2653fa7d9493SBabu Moger } 2654fa7d9493SBabu Moger 2655fa7d9493SBabu Moger /* 2656fa7d9493SBabu Moger * Move tasks from one to the other group. If @from is NULL, then all tasks 2657fa7d9493SBabu Moger * in the systems are moved unconditionally (used for teardown). 2658fa7d9493SBabu Moger * 2659fa7d9493SBabu Moger * If @mask is not NULL the cpus on which moved tasks are running are set 2660fa7d9493SBabu Moger * in that mask so the update smp function call is restricted to affected 2661fa7d9493SBabu Moger * cpus. 2662fa7d9493SBabu Moger */ 2663fa7d9493SBabu Moger static void rdt_move_group_tasks(struct rdtgroup *from, struct rdtgroup *to, 2664fa7d9493SBabu Moger struct cpumask *mask) 2665fa7d9493SBabu Moger { 2666fa7d9493SBabu Moger struct task_struct *p, *t; 2667fa7d9493SBabu Moger 2668fa7d9493SBabu Moger read_lock(&tasklist_lock); 2669fa7d9493SBabu Moger for_each_process_thread(p, t) { 2670fa7d9493SBabu Moger if (!from || is_closid_match(t, from) || 2671fa7d9493SBabu Moger is_rmid_match(t, from)) { 26726d3b47ddSValentin Schneider WRITE_ONCE(t->closid, to->closid); 26736d3b47ddSValentin Schneider WRITE_ONCE(t->rmid, to->mon.rmid); 2674fa7d9493SBabu Moger 2675fa7d9493SBabu Moger /* 2676fe1f0714SPeter Newman * Order the closid/rmid stores above before the loads 2677fe1f0714SPeter Newman * in task_curr(). This pairs with the full barrier 2678fe1f0714SPeter Newman * between the rq->curr update and resctrl_sched_in() 2679fe1f0714SPeter Newman * during context switch. 2680fe1f0714SPeter Newman */ 2681fe1f0714SPeter Newman smp_mb(); 2682fe1f0714SPeter Newman 2683fe1f0714SPeter Newman /* 2684e0ad6dc8SReinette Chatre * If the task is on a CPU, set the CPU in the mask. 2685e0ad6dc8SReinette Chatre * The detection is inaccurate as tasks might move or 2686e0ad6dc8SReinette Chatre * schedule before the smp function call takes place. 2687e0ad6dc8SReinette Chatre * In such a case the function call is pointless, but 2688fa7d9493SBabu Moger * there is no other side effect. 2689fa7d9493SBabu Moger */ 2690e0ad6dc8SReinette Chatre if (IS_ENABLED(CONFIG_SMP) && mask && task_curr(t)) 2691fa7d9493SBabu Moger cpumask_set_cpu(task_cpu(t), mask); 2692fa7d9493SBabu Moger } 2693fa7d9493SBabu Moger } 2694fa7d9493SBabu Moger read_unlock(&tasklist_lock); 2695fa7d9493SBabu Moger } 2696fa7d9493SBabu Moger 2697fa7d9493SBabu Moger static void free_all_child_rdtgrp(struct rdtgroup *rdtgrp) 2698fa7d9493SBabu Moger { 2699fa7d9493SBabu Moger struct rdtgroup *sentry, *stmp; 2700fa7d9493SBabu Moger struct list_head *head; 2701fa7d9493SBabu Moger 2702fa7d9493SBabu Moger head = &rdtgrp->mon.crdtgrp_list; 2703fa7d9493SBabu Moger list_for_each_entry_safe(sentry, stmp, head, mon.crdtgrp_list) { 2704fa7d9493SBabu Moger free_rmid(sentry->mon.rmid); 2705fa7d9493SBabu Moger list_del(&sentry->mon.crdtgrp_list); 2706b8511cccSXiaochen Shen 2707b8511cccSXiaochen Shen if (atomic_read(&sentry->waitcount) != 0) 2708b8511cccSXiaochen Shen sentry->flags = RDT_DELETED; 2709b8511cccSXiaochen Shen else 271075899924SXiaochen Shen rdtgroup_remove(sentry); 2711fa7d9493SBabu Moger } 2712fa7d9493SBabu Moger } 2713fa7d9493SBabu Moger 2714fa7d9493SBabu Moger /* 2715fa7d9493SBabu Moger * Forcibly remove all of subdirectories under root. 2716fa7d9493SBabu Moger */ 2717fa7d9493SBabu Moger static void rmdir_all_sub(void) 2718fa7d9493SBabu Moger { 2719fa7d9493SBabu Moger struct rdtgroup *rdtgrp, *tmp; 2720fa7d9493SBabu Moger 2721fa7d9493SBabu Moger /* Move all tasks to the default resource group */ 2722fa7d9493SBabu Moger rdt_move_group_tasks(NULL, &rdtgroup_default, NULL); 2723fa7d9493SBabu Moger 2724fa7d9493SBabu Moger list_for_each_entry_safe(rdtgrp, tmp, &rdt_all_groups, rdtgroup_list) { 2725fa7d9493SBabu Moger /* Free any child rmids */ 2726fa7d9493SBabu Moger free_all_child_rdtgrp(rdtgrp); 2727fa7d9493SBabu Moger 2728fa7d9493SBabu Moger /* Remove each rdtgroup other than root */ 2729fa7d9493SBabu Moger if (rdtgrp == &rdtgroup_default) 2730fa7d9493SBabu Moger continue; 2731fa7d9493SBabu Moger 2732fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2733fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2734fa7d9493SBabu Moger rdtgroup_pseudo_lock_remove(rdtgrp); 2735fa7d9493SBabu Moger 2736fa7d9493SBabu Moger /* 2737fa7d9493SBabu Moger * Give any CPUs back to the default group. We cannot copy 2738fa7d9493SBabu Moger * cpu_online_mask because a CPU might have executed the 2739fa7d9493SBabu Moger * offline callback already, but is still marked online. 2740fa7d9493SBabu Moger */ 2741fa7d9493SBabu Moger cpumask_or(&rdtgroup_default.cpu_mask, 2742fa7d9493SBabu Moger &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 2743fa7d9493SBabu Moger 2744fa7d9493SBabu Moger free_rmid(rdtgrp->mon.rmid); 2745fa7d9493SBabu Moger 2746fa7d9493SBabu Moger kernfs_remove(rdtgrp->kn); 2747fa7d9493SBabu Moger list_del(&rdtgrp->rdtgroup_list); 2748b8511cccSXiaochen Shen 2749b8511cccSXiaochen Shen if (atomic_read(&rdtgrp->waitcount) != 0) 2750b8511cccSXiaochen Shen rdtgrp->flags = RDT_DELETED; 2751b8511cccSXiaochen Shen else 275275899924SXiaochen Shen rdtgroup_remove(rdtgrp); 2753fa7d9493SBabu Moger } 2754fa7d9493SBabu Moger /* Notify online CPUs to update per cpu storage and PQR_ASSOC MSR */ 2755fa7d9493SBabu Moger update_closid_rmid(cpu_online_mask, &rdtgroup_default); 2756fa7d9493SBabu Moger 2757fa7d9493SBabu Moger kernfs_remove(kn_info); 2758fa7d9493SBabu Moger kernfs_remove(kn_mongrp); 2759fa7d9493SBabu Moger kernfs_remove(kn_mondata); 2760fa7d9493SBabu Moger } 2761fa7d9493SBabu Moger 2762fa7d9493SBabu Moger static void rdt_kill_sb(struct super_block *sb) 2763fa7d9493SBabu Moger { 2764fa7d9493SBabu Moger struct rdt_resource *r; 2765fa7d9493SBabu Moger 2766fa7d9493SBabu Moger cpus_read_lock(); 2767fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 2768fa7d9493SBabu Moger 2769fa7d9493SBabu Moger set_mba_sc(false); 2770fa7d9493SBabu Moger 2771fa7d9493SBabu Moger /*Put everything back to default values. */ 27724d269ed4SJames Morse for_each_alloc_capable_rdt_resource(r) 2773fa7d9493SBabu Moger reset_all_ctrls(r); 2774fa7d9493SBabu Moger cdp_disable_all(); 2775fa7d9493SBabu Moger rmdir_all_sub(); 2776fa7d9493SBabu Moger rdt_pseudo_lock_release(); 2777fa7d9493SBabu Moger rdtgroup_default.mode = RDT_MODE_SHAREABLE; 2778cdb9ebc9SJames Morse schemata_list_destroy(); 2779fa7d9493SBabu Moger static_branch_disable_cpuslocked(&rdt_alloc_enable_key); 2780fa7d9493SBabu Moger static_branch_disable_cpuslocked(&rdt_mon_enable_key); 2781fa7d9493SBabu Moger static_branch_disable_cpuslocked(&rdt_enable_key); 2782fa7d9493SBabu Moger kernfs_kill_sb(sb); 2783fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 2784fa7d9493SBabu Moger cpus_read_unlock(); 2785fa7d9493SBabu Moger } 2786fa7d9493SBabu Moger 2787fa7d9493SBabu Moger static struct file_system_type rdt_fs_type = { 2788fa7d9493SBabu Moger .name = "resctrl", 278923bf1b6bSDavid Howells .init_fs_context = rdt_init_fs_context, 2790d7167b14SAl Viro .parameters = rdt_fs_parameters, 2791fa7d9493SBabu Moger .kill_sb = rdt_kill_sb, 2792fa7d9493SBabu Moger }; 2793fa7d9493SBabu Moger 2794fa7d9493SBabu Moger static int mon_addfile(struct kernfs_node *parent_kn, const char *name, 2795fa7d9493SBabu Moger void *priv) 2796fa7d9493SBabu Moger { 2797fa7d9493SBabu Moger struct kernfs_node *kn; 2798fa7d9493SBabu Moger int ret = 0; 2799fa7d9493SBabu Moger 2800fa7d9493SBabu Moger kn = __kernfs_create_file(parent_kn, name, 0444, 2801fa7d9493SBabu Moger GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 0, 2802fa7d9493SBabu Moger &kf_mondata_ops, priv, NULL, NULL); 2803fa7d9493SBabu Moger if (IS_ERR(kn)) 2804fa7d9493SBabu Moger return PTR_ERR(kn); 2805fa7d9493SBabu Moger 2806fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 2807fa7d9493SBabu Moger if (ret) { 2808fa7d9493SBabu Moger kernfs_remove(kn); 2809fa7d9493SBabu Moger return ret; 2810fa7d9493SBabu Moger } 2811fa7d9493SBabu Moger 2812fa7d9493SBabu Moger return ret; 2813fa7d9493SBabu Moger } 2814fa7d9493SBabu Moger 2815fa7d9493SBabu Moger /* 2816fa7d9493SBabu Moger * Remove all subdirectories of mon_data of ctrl_mon groups 2817fa7d9493SBabu Moger * and monitor groups with given domain id. 2818fa7d9493SBabu Moger */ 2819798fd4b9SJames Morse static void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 2820798fd4b9SJames Morse unsigned int dom_id) 2821fa7d9493SBabu Moger { 2822fa7d9493SBabu Moger struct rdtgroup *prgrp, *crgrp; 2823fa7d9493SBabu Moger char name[32]; 2824fa7d9493SBabu Moger 2825fa7d9493SBabu Moger list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 2826fa7d9493SBabu Moger sprintf(name, "mon_%s_%02d", r->name, dom_id); 2827fa7d9493SBabu Moger kernfs_remove_by_name(prgrp->mon.mon_data_kn, name); 2828fa7d9493SBabu Moger 2829fa7d9493SBabu Moger list_for_each_entry(crgrp, &prgrp->mon.crdtgrp_list, mon.crdtgrp_list) 2830fa7d9493SBabu Moger kernfs_remove_by_name(crgrp->mon.mon_data_kn, name); 2831fa7d9493SBabu Moger } 2832fa7d9493SBabu Moger } 2833fa7d9493SBabu Moger 2834fa7d9493SBabu Moger static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, 2835fa7d9493SBabu Moger struct rdt_domain *d, 2836fa7d9493SBabu Moger struct rdt_resource *r, struct rdtgroup *prgrp) 2837fa7d9493SBabu Moger { 2838fa7d9493SBabu Moger union mon_data_bits priv; 2839fa7d9493SBabu Moger struct kernfs_node *kn; 2840fa7d9493SBabu Moger struct mon_evt *mevt; 2841fa7d9493SBabu Moger struct rmid_read rr; 2842fa7d9493SBabu Moger char name[32]; 2843fa7d9493SBabu Moger int ret; 2844fa7d9493SBabu Moger 2845fa7d9493SBabu Moger sprintf(name, "mon_%s_%02d", r->name, d->id); 2846fa7d9493SBabu Moger /* create the directory */ 2847fa7d9493SBabu Moger kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 2848fa7d9493SBabu Moger if (IS_ERR(kn)) 2849fa7d9493SBabu Moger return PTR_ERR(kn); 2850fa7d9493SBabu Moger 2851fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 2852fa7d9493SBabu Moger if (ret) 2853fa7d9493SBabu Moger goto out_destroy; 2854fa7d9493SBabu Moger 2855fa7d9493SBabu Moger if (WARN_ON(list_empty(&r->evt_list))) { 2856fa7d9493SBabu Moger ret = -EPERM; 2857fa7d9493SBabu Moger goto out_destroy; 2858fa7d9493SBabu Moger } 2859fa7d9493SBabu Moger 2860fa7d9493SBabu Moger priv.u.rid = r->rid; 2861fa7d9493SBabu Moger priv.u.domid = d->id; 2862fa7d9493SBabu Moger list_for_each_entry(mevt, &r->evt_list, list) { 2863fa7d9493SBabu Moger priv.u.evtid = mevt->evtid; 2864fa7d9493SBabu Moger ret = mon_addfile(kn, mevt->name, priv.priv); 2865fa7d9493SBabu Moger if (ret) 2866fa7d9493SBabu Moger goto out_destroy; 2867fa7d9493SBabu Moger 2868fa7d9493SBabu Moger if (is_mbm_event(mevt->evtid)) 286946637d45SReinette Chatre mon_event_read(&rr, r, d, prgrp, mevt->evtid, true); 2870fa7d9493SBabu Moger } 2871fa7d9493SBabu Moger kernfs_activate(kn); 2872fa7d9493SBabu Moger return 0; 2873fa7d9493SBabu Moger 2874fa7d9493SBabu Moger out_destroy: 2875fa7d9493SBabu Moger kernfs_remove(kn); 2876fa7d9493SBabu Moger return ret; 2877fa7d9493SBabu Moger } 2878fa7d9493SBabu Moger 2879fa7d9493SBabu Moger /* 2880fa7d9493SBabu Moger * Add all subdirectories of mon_data for "ctrl_mon" groups 2881fa7d9493SBabu Moger * and "monitor" groups with given domain id. 2882fa7d9493SBabu Moger */ 28833a7232cdSJames Morse static void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 2884fa7d9493SBabu Moger struct rdt_domain *d) 2885fa7d9493SBabu Moger { 2886fa7d9493SBabu Moger struct kernfs_node *parent_kn; 2887fa7d9493SBabu Moger struct rdtgroup *prgrp, *crgrp; 2888fa7d9493SBabu Moger struct list_head *head; 2889fa7d9493SBabu Moger 2890fa7d9493SBabu Moger list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 2891fa7d9493SBabu Moger parent_kn = prgrp->mon.mon_data_kn; 2892fa7d9493SBabu Moger mkdir_mondata_subdir(parent_kn, d, r, prgrp); 2893fa7d9493SBabu Moger 2894fa7d9493SBabu Moger head = &prgrp->mon.crdtgrp_list; 2895fa7d9493SBabu Moger list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 2896fa7d9493SBabu Moger parent_kn = crgrp->mon.mon_data_kn; 2897fa7d9493SBabu Moger mkdir_mondata_subdir(parent_kn, d, r, crgrp); 2898fa7d9493SBabu Moger } 2899fa7d9493SBabu Moger } 2900fa7d9493SBabu Moger } 2901fa7d9493SBabu Moger 2902fa7d9493SBabu Moger static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, 2903fa7d9493SBabu Moger struct rdt_resource *r, 2904fa7d9493SBabu Moger struct rdtgroup *prgrp) 2905fa7d9493SBabu Moger { 2906fa7d9493SBabu Moger struct rdt_domain *dom; 2907fa7d9493SBabu Moger int ret; 2908fa7d9493SBabu Moger 2909fa7d9493SBabu Moger list_for_each_entry(dom, &r->domains, list) { 2910fa7d9493SBabu Moger ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp); 2911fa7d9493SBabu Moger if (ret) 2912fa7d9493SBabu Moger return ret; 2913fa7d9493SBabu Moger } 2914fa7d9493SBabu Moger 2915fa7d9493SBabu Moger return 0; 2916fa7d9493SBabu Moger } 2917fa7d9493SBabu Moger 2918fa7d9493SBabu Moger /* 2919fa7d9493SBabu Moger * This creates a directory mon_data which contains the monitored data. 2920fa7d9493SBabu Moger * 2921163b0991SIngo Molnar * mon_data has one directory for each domain which are named 2922fa7d9493SBabu Moger * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data 2923fa7d9493SBabu Moger * with L3 domain looks as below: 2924fa7d9493SBabu Moger * ./mon_data: 2925fa7d9493SBabu Moger * mon_L3_00 2926fa7d9493SBabu Moger * mon_L3_01 2927fa7d9493SBabu Moger * mon_L3_02 2928fa7d9493SBabu Moger * ... 2929fa7d9493SBabu Moger * 2930fa7d9493SBabu Moger * Each domain directory has one file per event: 2931fa7d9493SBabu Moger * ./mon_L3_00/: 2932fa7d9493SBabu Moger * llc_occupancy 2933fa7d9493SBabu Moger * 2934fa7d9493SBabu Moger */ 2935fa7d9493SBabu Moger static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2936fa7d9493SBabu Moger struct rdtgroup *prgrp, 2937fa7d9493SBabu Moger struct kernfs_node **dest_kn) 2938fa7d9493SBabu Moger { 2939fa7d9493SBabu Moger struct rdt_resource *r; 2940fa7d9493SBabu Moger struct kernfs_node *kn; 2941fa7d9493SBabu Moger int ret; 2942fa7d9493SBabu Moger 2943fa7d9493SBabu Moger /* 2944fa7d9493SBabu Moger * Create the mon_data directory first. 2945fa7d9493SBabu Moger */ 2946334b0f4eSXiaochen Shen ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn); 2947fa7d9493SBabu Moger if (ret) 2948fa7d9493SBabu Moger return ret; 2949fa7d9493SBabu Moger 2950fa7d9493SBabu Moger if (dest_kn) 2951fa7d9493SBabu Moger *dest_kn = kn; 2952fa7d9493SBabu Moger 2953fa7d9493SBabu Moger /* 2954fa7d9493SBabu Moger * Create the subdirectories for each domain. Note that all events 2955fa7d9493SBabu Moger * in a domain like L3 are grouped into a resource whose domain is L3 2956fa7d9493SBabu Moger */ 2957bab6ee73SJames Morse for_each_mon_capable_rdt_resource(r) { 2958fa7d9493SBabu Moger ret = mkdir_mondata_subdir_alldom(kn, r, prgrp); 2959fa7d9493SBabu Moger if (ret) 2960fa7d9493SBabu Moger goto out_destroy; 2961fa7d9493SBabu Moger } 2962fa7d9493SBabu Moger 2963fa7d9493SBabu Moger return 0; 2964fa7d9493SBabu Moger 2965fa7d9493SBabu Moger out_destroy: 2966fa7d9493SBabu Moger kernfs_remove(kn); 2967fa7d9493SBabu Moger return ret; 2968fa7d9493SBabu Moger } 2969fa7d9493SBabu Moger 2970fa7d9493SBabu Moger /** 2971fa7d9493SBabu Moger * cbm_ensure_valid - Enforce validity on provided CBM 2972fa7d9493SBabu Moger * @_val: Candidate CBM 2973fa7d9493SBabu Moger * @r: RDT resource to which the CBM belongs 2974fa7d9493SBabu Moger * 2975fa7d9493SBabu Moger * The provided CBM represents all cache portions available for use. This 2976fa7d9493SBabu Moger * may be represented by a bitmap that does not consist of contiguous ones 2977fa7d9493SBabu Moger * and thus be an invalid CBM. 2978fa7d9493SBabu Moger * Here the provided CBM is forced to be a valid CBM by only considering 2979fa7d9493SBabu Moger * the first set of contiguous bits as valid and clearing all bits. 2980fa7d9493SBabu Moger * The intention here is to provide a valid default CBM with which a new 2981fa7d9493SBabu Moger * resource group is initialized. The user can follow this with a 2982fa7d9493SBabu Moger * modification to the CBM if the default does not satisfy the 2983fa7d9493SBabu Moger * requirements. 2984fa7d9493SBabu Moger */ 29852ef085bdSReinette Chatre static u32 cbm_ensure_valid(u32 _val, struct rdt_resource *r) 2986fa7d9493SBabu Moger { 2987fa7d9493SBabu Moger unsigned int cbm_len = r->cache.cbm_len; 2988fa7d9493SBabu Moger unsigned long first_bit, zero_bit; 29892ef085bdSReinette Chatre unsigned long val = _val; 2990fa7d9493SBabu Moger 29912ef085bdSReinette Chatre if (!val) 29922ef085bdSReinette Chatre return 0; 2993fa7d9493SBabu Moger 299432f010deSReinette Chatre first_bit = find_first_bit(&val, cbm_len); 299532f010deSReinette Chatre zero_bit = find_next_zero_bit(&val, cbm_len, first_bit); 2996fa7d9493SBabu Moger 2997fa7d9493SBabu Moger /* Clear any remaining bits to ensure contiguous region */ 299832f010deSReinette Chatre bitmap_clear(&val, zero_bit, cbm_len - zero_bit); 29992ef085bdSReinette Chatre return (u32)val; 3000fa7d9493SBabu Moger } 3001fa7d9493SBabu Moger 30027390619aSXiaochen Shen /* 30037390619aSXiaochen Shen * Initialize cache resources per RDT domain 3004fa7d9493SBabu Moger * 30057390619aSXiaochen Shen * Set the RDT domain up to start off with all usable allocations. That is, 30067390619aSXiaochen Shen * all shareable and unused bits. All-zero CBM is invalid. 3007fa7d9493SBabu Moger */ 30081c290682SJames Morse static int __init_one_rdt_domain(struct rdt_domain *d, struct resctrl_schema *s, 30097390619aSXiaochen Shen u32 closid) 3010fa7d9493SBabu Moger { 3011fbc06c69SJames Morse enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 301275408e43SJames Morse enum resctrl_conf_type t = s->conf_type; 3013e8f72825SJames Morse struct resctrl_staged_config *cfg; 30141c290682SJames Morse struct rdt_resource *r = s->res; 3015fa7d9493SBabu Moger u32 used_b = 0, unused_b = 0; 3016fa7d9493SBabu Moger unsigned long tmp_cbm; 3017fa7d9493SBabu Moger enum rdtgrp_mode mode; 3018f07e9d02SJames Morse u32 peer_ctl, ctrl_val; 30197390619aSXiaochen Shen int i; 3020fa7d9493SBabu Moger 302175408e43SJames Morse cfg = &d->staged_config[t]; 3022e8f72825SJames Morse cfg->have_new_ctrl = false; 3023e8f72825SJames Morse cfg->new_ctrl = r->cache.shareable_bits; 3024fa7d9493SBabu Moger used_b = r->cache.shareable_bits; 3025f07e9d02SJames Morse for (i = 0; i < closids_supported(); i++) { 3026fa7d9493SBabu Moger if (closid_allocated(i) && i != closid) { 3027fa7d9493SBabu Moger mode = rdtgroup_mode_by_closid(i); 3028fa7d9493SBabu Moger if (mode == RDT_MODE_PSEUDO_LOCKSETUP) 302987d3aa28SJames Morse /* 303087d3aa28SJames Morse * ctrl values for locksetup aren't relevant 303187d3aa28SJames Morse * until the schemata is written, and the mode 303287d3aa28SJames Morse * becomes RDT_MODE_PSEUDO_LOCKED. 303387d3aa28SJames Morse */ 303487d3aa28SJames Morse continue; 3035fa7d9493SBabu Moger /* 30367390619aSXiaochen Shen * If CDP is active include peer domain's 30377390619aSXiaochen Shen * usage to ensure there is no overlap 30387390619aSXiaochen Shen * with an exclusive group. 3039fa7d9493SBabu Moger */ 3040fbc06c69SJames Morse if (resctrl_arch_get_cdp_enabled(r->rid)) 3041111136e6SJames Morse peer_ctl = resctrl_arch_get_config(r, d, i, 3042111136e6SJames Morse peer_type); 3043fa7d9493SBabu Moger else 3044fa7d9493SBabu Moger peer_ctl = 0; 3045111136e6SJames Morse ctrl_val = resctrl_arch_get_config(r, d, i, 3046111136e6SJames Morse s->conf_type); 3047f07e9d02SJames Morse used_b |= ctrl_val | peer_ctl; 3048fa7d9493SBabu Moger if (mode == RDT_MODE_SHAREABLE) 3049f07e9d02SJames Morse cfg->new_ctrl |= ctrl_val | peer_ctl; 3050fa7d9493SBabu Moger } 3051fa7d9493SBabu Moger } 3052fa7d9493SBabu Moger if (d->plr && d->plr->cbm > 0) 3053fa7d9493SBabu Moger used_b |= d->plr->cbm; 3054fa7d9493SBabu Moger unused_b = used_b ^ (BIT_MASK(r->cache.cbm_len) - 1); 3055fa7d9493SBabu Moger unused_b &= BIT_MASK(r->cache.cbm_len) - 1; 3056e8f72825SJames Morse cfg->new_ctrl |= unused_b; 3057fa7d9493SBabu Moger /* 3058fa7d9493SBabu Moger * Force the initial CBM to be valid, user can 3059fa7d9493SBabu Moger * modify the CBM based on system availability. 3060fa7d9493SBabu Moger */ 3061e8f72825SJames Morse cfg->new_ctrl = cbm_ensure_valid(cfg->new_ctrl, r); 3062fa7d9493SBabu Moger /* 30637390619aSXiaochen Shen * Assign the u32 CBM to an unsigned long to ensure that 30647390619aSXiaochen Shen * bitmap_weight() does not access out-of-bound memory. 3065fa7d9493SBabu Moger */ 3066e8f72825SJames Morse tmp_cbm = cfg->new_ctrl; 30677390619aSXiaochen Shen if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) { 3068e198fde3SJames Morse rdt_last_cmd_printf("No space on %s:%d\n", s->name, d->id); 3069fa7d9493SBabu Moger return -ENOSPC; 3070fa7d9493SBabu Moger } 3071e8f72825SJames Morse cfg->have_new_ctrl = true; 30727390619aSXiaochen Shen 30737390619aSXiaochen Shen return 0; 30747390619aSXiaochen Shen } 30757390619aSXiaochen Shen 307647820e73SXiaochen Shen /* 307747820e73SXiaochen Shen * Initialize cache resources with default values. 30787390619aSXiaochen Shen * 30797390619aSXiaochen Shen * A new RDT group is being created on an allocation capable (CAT) 30807390619aSXiaochen Shen * supporting system. Set this group up to start off with all usable 30817390619aSXiaochen Shen * allocations. 30827390619aSXiaochen Shen * 30837390619aSXiaochen Shen * If there are no more shareable bits available on any domain then 30847390619aSXiaochen Shen * the entire allocation will fail. 30857390619aSXiaochen Shen */ 30861c290682SJames Morse static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) 30877390619aSXiaochen Shen { 30887390619aSXiaochen Shen struct rdt_domain *d; 30897390619aSXiaochen Shen int ret; 30907390619aSXiaochen Shen 30911c290682SJames Morse list_for_each_entry(d, &s->res->domains, list) { 30921c290682SJames Morse ret = __init_one_rdt_domain(d, s, closid); 30937390619aSXiaochen Shen if (ret < 0) 30947390619aSXiaochen Shen return ret; 3095fa7d9493SBabu Moger } 309647820e73SXiaochen Shen 309747820e73SXiaochen Shen return 0; 3098fa7d9493SBabu Moger } 3099fa7d9493SBabu Moger 310047820e73SXiaochen Shen /* Initialize MBA resource with default values. */ 31016ce1560dSJames Morse static void rdtgroup_init_mba(struct rdt_resource *r, u32 closid) 310247820e73SXiaochen Shen { 3103e8f72825SJames Morse struct resctrl_staged_config *cfg; 310447820e73SXiaochen Shen struct rdt_domain *d; 310547820e73SXiaochen Shen 310647820e73SXiaochen Shen list_for_each_entry(d, &r->domains, list) { 31076ce1560dSJames Morse if (is_mba_sc(r)) { 31086ce1560dSJames Morse d->mbps_val[closid] = MBA_MAX_MBPS; 31096ce1560dSJames Morse continue; 31106ce1560dSJames Morse } 31116ce1560dSJames Morse 311275408e43SJames Morse cfg = &d->staged_config[CDP_NONE]; 31136ce1560dSJames Morse cfg->new_ctrl = r->default_ctrl; 3114e8f72825SJames Morse cfg->have_new_ctrl = true; 311547820e73SXiaochen Shen } 311647820e73SXiaochen Shen } 311747820e73SXiaochen Shen 311847820e73SXiaochen Shen /* Initialize the RDT group's allocations. */ 311947820e73SXiaochen Shen static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp) 312047820e73SXiaochen Shen { 3121331ebe4cSJames Morse struct resctrl_schema *s; 312247820e73SXiaochen Shen struct rdt_resource *r; 3123*0424a7dfSShawn Wang int ret = 0; 3124*0424a7dfSShawn Wang 3125*0424a7dfSShawn Wang rdt_staged_configs_clear(); 312647820e73SXiaochen Shen 3127331ebe4cSJames Morse list_for_each_entry(s, &resctrl_schema_all, list) { 3128331ebe4cSJames Morse r = s->res; 31295b6fac3fSBabu Moger if (r->rid == RDT_RESOURCE_MBA || 31305b6fac3fSBabu Moger r->rid == RDT_RESOURCE_SMBA) { 31316ce1560dSJames Morse rdtgroup_init_mba(r, rdtgrp->closid); 31326ce1560dSJames Morse if (is_mba_sc(r)) 31336ce1560dSJames Morse continue; 313447820e73SXiaochen Shen } else { 31351c290682SJames Morse ret = rdtgroup_init_cat(s, rdtgrp->closid); 313647820e73SXiaochen Shen if (ret < 0) 3137*0424a7dfSShawn Wang goto out; 313847820e73SXiaochen Shen } 313947820e73SXiaochen Shen 31402e667819SJames Morse ret = resctrl_arch_update_domains(r, rdtgrp->closid); 3141fa7d9493SBabu Moger if (ret < 0) { 3142723f1a0dSBabu Moger rdt_last_cmd_puts("Failed to initialize allocations\n"); 3143*0424a7dfSShawn Wang goto out; 3144fa7d9493SBabu Moger } 314547820e73SXiaochen Shen 3146fa7d9493SBabu Moger } 3147fa7d9493SBabu Moger 314840fba00fSXiaochen Shen rdtgrp->mode = RDT_MODE_SHAREABLE; 314940fba00fSXiaochen Shen 3150*0424a7dfSShawn Wang out: 3151*0424a7dfSShawn Wang rdt_staged_configs_clear(); 3152*0424a7dfSShawn Wang return ret; 3153fa7d9493SBabu Moger } 3154fa7d9493SBabu Moger 3155fa7d9493SBabu Moger static int mkdir_rdt_prepare(struct kernfs_node *parent_kn, 3156fa7d9493SBabu Moger const char *name, umode_t mode, 3157fa7d9493SBabu Moger enum rdt_group_type rtype, struct rdtgroup **r) 3158fa7d9493SBabu Moger { 3159fa7d9493SBabu Moger struct rdtgroup *prdtgrp, *rdtgrp; 3160fa7d9493SBabu Moger struct kernfs_node *kn; 3161fa7d9493SBabu Moger uint files = 0; 3162fa7d9493SBabu Moger int ret; 3163fa7d9493SBabu Moger 3164334b0f4eSXiaochen Shen prdtgrp = rdtgroup_kn_lock_live(parent_kn); 3165fa7d9493SBabu Moger if (!prdtgrp) { 3166fa7d9493SBabu Moger ret = -ENODEV; 3167fa7d9493SBabu Moger goto out_unlock; 3168fa7d9493SBabu Moger } 3169fa7d9493SBabu Moger 3170fa7d9493SBabu Moger if (rtype == RDTMON_GROUP && 3171fa7d9493SBabu Moger (prdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 3172fa7d9493SBabu Moger prdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)) { 3173fa7d9493SBabu Moger ret = -EINVAL; 3174723f1a0dSBabu Moger rdt_last_cmd_puts("Pseudo-locking in progress\n"); 3175fa7d9493SBabu Moger goto out_unlock; 3176fa7d9493SBabu Moger } 3177fa7d9493SBabu Moger 3178fa7d9493SBabu Moger /* allocate the rdtgroup. */ 3179fa7d9493SBabu Moger rdtgrp = kzalloc(sizeof(*rdtgrp), GFP_KERNEL); 3180fa7d9493SBabu Moger if (!rdtgrp) { 3181fa7d9493SBabu Moger ret = -ENOSPC; 3182723f1a0dSBabu Moger rdt_last_cmd_puts("Kernel out of memory\n"); 3183fa7d9493SBabu Moger goto out_unlock; 3184fa7d9493SBabu Moger } 3185fa7d9493SBabu Moger *r = rdtgrp; 3186fa7d9493SBabu Moger rdtgrp->mon.parent = prdtgrp; 3187fa7d9493SBabu Moger rdtgrp->type = rtype; 3188fa7d9493SBabu Moger INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list); 3189fa7d9493SBabu Moger 3190fa7d9493SBabu Moger /* kernfs creates the directory for rdtgrp */ 3191fa7d9493SBabu Moger kn = kernfs_create_dir(parent_kn, name, mode, rdtgrp); 3192fa7d9493SBabu Moger if (IS_ERR(kn)) { 3193fa7d9493SBabu Moger ret = PTR_ERR(kn); 3194fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs create error\n"); 3195fa7d9493SBabu Moger goto out_free_rgrp; 3196fa7d9493SBabu Moger } 3197fa7d9493SBabu Moger rdtgrp->kn = kn; 3198fa7d9493SBabu Moger 3199fa7d9493SBabu Moger /* 3200fa7d9493SBabu Moger * kernfs_remove() will drop the reference count on "kn" which 3201fa7d9493SBabu Moger * will free it. But we still need it to stick around for the 3202fd8d9db3SXiaochen Shen * rdtgroup_kn_unlock(kn) call. Take one extra reference here, 320375899924SXiaochen Shen * which will be dropped by kernfs_put() in rdtgroup_remove(). 3204fa7d9493SBabu Moger */ 3205fa7d9493SBabu Moger kernfs_get(kn); 3206fa7d9493SBabu Moger 3207fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 3208fa7d9493SBabu Moger if (ret) { 3209fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs perm error\n"); 3210fa7d9493SBabu Moger goto out_destroy; 3211fa7d9493SBabu Moger } 3212fa7d9493SBabu Moger 3213fa7d9493SBabu Moger files = RFTYPE_BASE | BIT(RF_CTRLSHIFT + rtype); 3214fa7d9493SBabu Moger ret = rdtgroup_add_files(kn, files); 3215fa7d9493SBabu Moger if (ret) { 3216fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs fill error\n"); 3217fa7d9493SBabu Moger goto out_destroy; 3218fa7d9493SBabu Moger } 3219fa7d9493SBabu Moger 3220fa7d9493SBabu Moger if (rdt_mon_capable) { 3221fa7d9493SBabu Moger ret = alloc_rmid(); 3222fa7d9493SBabu Moger if (ret < 0) { 3223723f1a0dSBabu Moger rdt_last_cmd_puts("Out of RMIDs\n"); 3224fa7d9493SBabu Moger goto out_destroy; 3225fa7d9493SBabu Moger } 3226fa7d9493SBabu Moger rdtgrp->mon.rmid = ret; 3227fa7d9493SBabu Moger 3228fa7d9493SBabu Moger ret = mkdir_mondata_all(kn, rdtgrp, &rdtgrp->mon.mon_data_kn); 3229fa7d9493SBabu Moger if (ret) { 3230fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs subdir error\n"); 3231fa7d9493SBabu Moger goto out_idfree; 3232fa7d9493SBabu Moger } 3233fa7d9493SBabu Moger } 3234fa7d9493SBabu Moger kernfs_activate(kn); 3235fa7d9493SBabu Moger 3236fa7d9493SBabu Moger /* 3237334b0f4eSXiaochen Shen * The caller unlocks the parent_kn upon success. 3238fa7d9493SBabu Moger */ 3239fa7d9493SBabu Moger return 0; 3240fa7d9493SBabu Moger 3241fa7d9493SBabu Moger out_idfree: 3242fa7d9493SBabu Moger free_rmid(rdtgrp->mon.rmid); 3243fa7d9493SBabu Moger out_destroy: 324475899924SXiaochen Shen kernfs_put(rdtgrp->kn); 3245fa7d9493SBabu Moger kernfs_remove(rdtgrp->kn); 3246fa7d9493SBabu Moger out_free_rgrp: 3247fa7d9493SBabu Moger kfree(rdtgrp); 3248fa7d9493SBabu Moger out_unlock: 3249334b0f4eSXiaochen Shen rdtgroup_kn_unlock(parent_kn); 3250fa7d9493SBabu Moger return ret; 3251fa7d9493SBabu Moger } 3252fa7d9493SBabu Moger 3253fa7d9493SBabu Moger static void mkdir_rdt_prepare_clean(struct rdtgroup *rgrp) 3254fa7d9493SBabu Moger { 3255fa7d9493SBabu Moger kernfs_remove(rgrp->kn); 3256fa7d9493SBabu Moger free_rmid(rgrp->mon.rmid); 325775899924SXiaochen Shen rdtgroup_remove(rgrp); 3258fa7d9493SBabu Moger } 3259fa7d9493SBabu Moger 3260fa7d9493SBabu Moger /* 3261fa7d9493SBabu Moger * Create a monitor group under "mon_groups" directory of a control 3262fa7d9493SBabu Moger * and monitor group(ctrl_mon). This is a resource group 3263fa7d9493SBabu Moger * to monitor a subset of tasks and cpus in its parent ctrl_mon group. 3264fa7d9493SBabu Moger */ 3265fa7d9493SBabu Moger static int rdtgroup_mkdir_mon(struct kernfs_node *parent_kn, 326632ada3b9SXiaochen Shen const char *name, umode_t mode) 3267fa7d9493SBabu Moger { 3268fa7d9493SBabu Moger struct rdtgroup *rdtgrp, *prgrp; 3269fa7d9493SBabu Moger int ret; 3270fa7d9493SBabu Moger 327132ada3b9SXiaochen Shen ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTMON_GROUP, &rdtgrp); 3272fa7d9493SBabu Moger if (ret) 3273fa7d9493SBabu Moger return ret; 3274fa7d9493SBabu Moger 3275fa7d9493SBabu Moger prgrp = rdtgrp->mon.parent; 3276fa7d9493SBabu Moger rdtgrp->closid = prgrp->closid; 3277fa7d9493SBabu Moger 3278fa7d9493SBabu Moger /* 3279fa7d9493SBabu Moger * Add the rdtgrp to the list of rdtgrps the parent 3280fa7d9493SBabu Moger * ctrl_mon group has to track. 3281fa7d9493SBabu Moger */ 3282fa7d9493SBabu Moger list_add_tail(&rdtgrp->mon.crdtgrp_list, &prgrp->mon.crdtgrp_list); 3283fa7d9493SBabu Moger 3284334b0f4eSXiaochen Shen rdtgroup_kn_unlock(parent_kn); 3285fa7d9493SBabu Moger return ret; 3286fa7d9493SBabu Moger } 3287fa7d9493SBabu Moger 3288fa7d9493SBabu Moger /* 3289fa7d9493SBabu Moger * These are rdtgroups created under the root directory. Can be used 3290fa7d9493SBabu Moger * to allocate and monitor resources. 3291fa7d9493SBabu Moger */ 3292fa7d9493SBabu Moger static int rdtgroup_mkdir_ctrl_mon(struct kernfs_node *parent_kn, 3293fa7d9493SBabu Moger const char *name, umode_t mode) 3294fa7d9493SBabu Moger { 3295fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 3296fa7d9493SBabu Moger struct kernfs_node *kn; 3297fa7d9493SBabu Moger u32 closid; 3298fa7d9493SBabu Moger int ret; 3299fa7d9493SBabu Moger 330032ada3b9SXiaochen Shen ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTCTRL_GROUP, &rdtgrp); 3301fa7d9493SBabu Moger if (ret) 3302fa7d9493SBabu Moger return ret; 3303fa7d9493SBabu Moger 3304fa7d9493SBabu Moger kn = rdtgrp->kn; 3305fa7d9493SBabu Moger ret = closid_alloc(); 3306fa7d9493SBabu Moger if (ret < 0) { 3307723f1a0dSBabu Moger rdt_last_cmd_puts("Out of CLOSIDs\n"); 3308fa7d9493SBabu Moger goto out_common_fail; 3309fa7d9493SBabu Moger } 3310fa7d9493SBabu Moger closid = ret; 3311fa7d9493SBabu Moger ret = 0; 3312fa7d9493SBabu Moger 3313fa7d9493SBabu Moger rdtgrp->closid = closid; 3314fa7d9493SBabu Moger ret = rdtgroup_init_alloc(rdtgrp); 3315fa7d9493SBabu Moger if (ret < 0) 3316fa7d9493SBabu Moger goto out_id_free; 3317fa7d9493SBabu Moger 3318fa7d9493SBabu Moger list_add(&rdtgrp->rdtgroup_list, &rdt_all_groups); 3319fa7d9493SBabu Moger 3320fa7d9493SBabu Moger if (rdt_mon_capable) { 3321fa7d9493SBabu Moger /* 3322fa7d9493SBabu Moger * Create an empty mon_groups directory to hold the subset 3323fa7d9493SBabu Moger * of tasks and cpus to monitor. 3324fa7d9493SBabu Moger */ 3325334b0f4eSXiaochen Shen ret = mongroup_create_dir(kn, rdtgrp, "mon_groups", NULL); 3326fa7d9493SBabu Moger if (ret) { 3327fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs subdir error\n"); 3328fa7d9493SBabu Moger goto out_del_list; 3329fa7d9493SBabu Moger } 3330fa7d9493SBabu Moger } 3331fa7d9493SBabu Moger 3332fa7d9493SBabu Moger goto out_unlock; 3333fa7d9493SBabu Moger 3334fa7d9493SBabu Moger out_del_list: 3335fa7d9493SBabu Moger list_del(&rdtgrp->rdtgroup_list); 3336fa7d9493SBabu Moger out_id_free: 3337fa7d9493SBabu Moger closid_free(closid); 3338fa7d9493SBabu Moger out_common_fail: 3339fa7d9493SBabu Moger mkdir_rdt_prepare_clean(rdtgrp); 3340fa7d9493SBabu Moger out_unlock: 3341334b0f4eSXiaochen Shen rdtgroup_kn_unlock(parent_kn); 3342fa7d9493SBabu Moger return ret; 3343fa7d9493SBabu Moger } 3344fa7d9493SBabu Moger 3345fa7d9493SBabu Moger /* 3346fa7d9493SBabu Moger * We allow creating mon groups only with in a directory called "mon_groups" 3347fa7d9493SBabu Moger * which is present in every ctrl_mon group. Check if this is a valid 3348fa7d9493SBabu Moger * "mon_groups" directory. 3349fa7d9493SBabu Moger * 3350fa7d9493SBabu Moger * 1. The directory should be named "mon_groups". 3351fa7d9493SBabu Moger * 2. The mon group itself should "not" be named "mon_groups". 3352fa7d9493SBabu Moger * This makes sure "mon_groups" directory always has a ctrl_mon group 3353fa7d9493SBabu Moger * as parent. 3354fa7d9493SBabu Moger */ 3355fa7d9493SBabu Moger static bool is_mon_groups(struct kernfs_node *kn, const char *name) 3356fa7d9493SBabu Moger { 3357fa7d9493SBabu Moger return (!strcmp(kn->name, "mon_groups") && 3358fa7d9493SBabu Moger strcmp(name, "mon_groups")); 3359fa7d9493SBabu Moger } 3360fa7d9493SBabu Moger 3361fa7d9493SBabu Moger static int rdtgroup_mkdir(struct kernfs_node *parent_kn, const char *name, 3362fa7d9493SBabu Moger umode_t mode) 3363fa7d9493SBabu Moger { 3364fa7d9493SBabu Moger /* Do not accept '\n' to avoid unparsable situation. */ 3365fa7d9493SBabu Moger if (strchr(name, '\n')) 3366fa7d9493SBabu Moger return -EINVAL; 3367fa7d9493SBabu Moger 3368fa7d9493SBabu Moger /* 3369fa7d9493SBabu Moger * If the parent directory is the root directory and RDT 3370fa7d9493SBabu Moger * allocation is supported, add a control and monitoring 3371fa7d9493SBabu Moger * subdirectory 3372fa7d9493SBabu Moger */ 3373fa7d9493SBabu Moger if (rdt_alloc_capable && parent_kn == rdtgroup_default.kn) 337432ada3b9SXiaochen Shen return rdtgroup_mkdir_ctrl_mon(parent_kn, name, mode); 3375fa7d9493SBabu Moger 3376fa7d9493SBabu Moger /* 3377fa7d9493SBabu Moger * If RDT monitoring is supported and the parent directory is a valid 3378fa7d9493SBabu Moger * "mon_groups" directory, add a monitoring subdirectory. 3379fa7d9493SBabu Moger */ 3380fa7d9493SBabu Moger if (rdt_mon_capable && is_mon_groups(parent_kn, name)) 338132ada3b9SXiaochen Shen return rdtgroup_mkdir_mon(parent_kn, name, mode); 3382fa7d9493SBabu Moger 3383fa7d9493SBabu Moger return -EPERM; 3384fa7d9493SBabu Moger } 3385fa7d9493SBabu Moger 338619eb86a7SXiaochen Shen static int rdtgroup_rmdir_mon(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3387fa7d9493SBabu Moger { 3388fa7d9493SBabu Moger struct rdtgroup *prdtgrp = rdtgrp->mon.parent; 3389fa7d9493SBabu Moger int cpu; 3390fa7d9493SBabu Moger 3391fa7d9493SBabu Moger /* Give any tasks back to the parent group */ 3392fa7d9493SBabu Moger rdt_move_group_tasks(rdtgrp, prdtgrp, tmpmask); 3393fa7d9493SBabu Moger 3394fa7d9493SBabu Moger /* Update per cpu rmid of the moved CPUs first */ 3395fa7d9493SBabu Moger for_each_cpu(cpu, &rdtgrp->cpu_mask) 3396fa7d9493SBabu Moger per_cpu(pqr_state.default_rmid, cpu) = prdtgrp->mon.rmid; 3397fa7d9493SBabu Moger /* 3398fa7d9493SBabu Moger * Update the MSR on moved CPUs and CPUs which have moved 3399fa7d9493SBabu Moger * task running on them. 3400fa7d9493SBabu Moger */ 3401fa7d9493SBabu Moger cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3402fa7d9493SBabu Moger update_closid_rmid(tmpmask, NULL); 3403fa7d9493SBabu Moger 3404fa7d9493SBabu Moger rdtgrp->flags = RDT_DELETED; 3405fa7d9493SBabu Moger free_rmid(rdtgrp->mon.rmid); 3406fa7d9493SBabu Moger 3407fa7d9493SBabu Moger /* 3408fa7d9493SBabu Moger * Remove the rdtgrp from the parent ctrl_mon group's list 3409fa7d9493SBabu Moger */ 3410fa7d9493SBabu Moger WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list)); 3411fa7d9493SBabu Moger list_del(&rdtgrp->mon.crdtgrp_list); 3412fa7d9493SBabu Moger 3413fa7d9493SBabu Moger kernfs_remove(rdtgrp->kn); 3414fa7d9493SBabu Moger 3415fa7d9493SBabu Moger return 0; 3416fa7d9493SBabu Moger } 3417fa7d9493SBabu Moger 341819eb86a7SXiaochen Shen static int rdtgroup_ctrl_remove(struct rdtgroup *rdtgrp) 3419fa7d9493SBabu Moger { 3420fa7d9493SBabu Moger rdtgrp->flags = RDT_DELETED; 3421fa7d9493SBabu Moger list_del(&rdtgrp->rdtgroup_list); 3422fa7d9493SBabu Moger 3423fa7d9493SBabu Moger kernfs_remove(rdtgrp->kn); 3424fa7d9493SBabu Moger return 0; 3425fa7d9493SBabu Moger } 3426fa7d9493SBabu Moger 342719eb86a7SXiaochen Shen static int rdtgroup_rmdir_ctrl(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3428fa7d9493SBabu Moger { 3429fa7d9493SBabu Moger int cpu; 3430fa7d9493SBabu Moger 3431fa7d9493SBabu Moger /* Give any tasks back to the default group */ 3432fa7d9493SBabu Moger rdt_move_group_tasks(rdtgrp, &rdtgroup_default, tmpmask); 3433fa7d9493SBabu Moger 3434fa7d9493SBabu Moger /* Give any CPUs back to the default group */ 3435fa7d9493SBabu Moger cpumask_or(&rdtgroup_default.cpu_mask, 3436fa7d9493SBabu Moger &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 3437fa7d9493SBabu Moger 3438fa7d9493SBabu Moger /* Update per cpu closid and rmid of the moved CPUs first */ 3439fa7d9493SBabu Moger for_each_cpu(cpu, &rdtgrp->cpu_mask) { 3440fa7d9493SBabu Moger per_cpu(pqr_state.default_closid, cpu) = rdtgroup_default.closid; 3441fa7d9493SBabu Moger per_cpu(pqr_state.default_rmid, cpu) = rdtgroup_default.mon.rmid; 3442fa7d9493SBabu Moger } 3443fa7d9493SBabu Moger 3444fa7d9493SBabu Moger /* 3445fa7d9493SBabu Moger * Update the MSR on moved CPUs and CPUs which have moved 3446fa7d9493SBabu Moger * task running on them. 3447fa7d9493SBabu Moger */ 3448fa7d9493SBabu Moger cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3449fa7d9493SBabu Moger update_closid_rmid(tmpmask, NULL); 3450fa7d9493SBabu Moger 3451fa7d9493SBabu Moger closid_free(rdtgrp->closid); 3452fa7d9493SBabu Moger free_rmid(rdtgrp->mon.rmid); 3453fa7d9493SBabu Moger 345419eb86a7SXiaochen Shen rdtgroup_ctrl_remove(rdtgrp); 3455074fadeeSXiaochen Shen 3456fa7d9493SBabu Moger /* 3457fa7d9493SBabu Moger * Free all the child monitor group rmids. 3458fa7d9493SBabu Moger */ 3459fa7d9493SBabu Moger free_all_child_rdtgrp(rdtgrp); 3460fa7d9493SBabu Moger 3461fa7d9493SBabu Moger return 0; 3462fa7d9493SBabu Moger } 3463fa7d9493SBabu Moger 3464fa7d9493SBabu Moger static int rdtgroup_rmdir(struct kernfs_node *kn) 3465fa7d9493SBabu Moger { 3466fa7d9493SBabu Moger struct kernfs_node *parent_kn = kn->parent; 3467fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 3468fa7d9493SBabu Moger cpumask_var_t tmpmask; 3469fa7d9493SBabu Moger int ret = 0; 3470fa7d9493SBabu Moger 3471fa7d9493SBabu Moger if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 3472fa7d9493SBabu Moger return -ENOMEM; 3473fa7d9493SBabu Moger 3474fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(kn); 3475fa7d9493SBabu Moger if (!rdtgrp) { 3476fa7d9493SBabu Moger ret = -EPERM; 3477fa7d9493SBabu Moger goto out; 3478fa7d9493SBabu Moger } 3479fa7d9493SBabu Moger 3480fa7d9493SBabu Moger /* 3481fa7d9493SBabu Moger * If the rdtgroup is a ctrl_mon group and parent directory 3482fa7d9493SBabu Moger * is the root directory, remove the ctrl_mon group. 3483fa7d9493SBabu Moger * 3484fa7d9493SBabu Moger * If the rdtgroup is a mon group and parent directory 3485fa7d9493SBabu Moger * is a valid "mon_groups" directory, remove the mon group. 3486fa7d9493SBabu Moger */ 3487b0151da5SReinette Chatre if (rdtgrp->type == RDTCTRL_GROUP && parent_kn == rdtgroup_default.kn && 3488b0151da5SReinette Chatre rdtgrp != &rdtgroup_default) { 3489fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 3490fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 349119eb86a7SXiaochen Shen ret = rdtgroup_ctrl_remove(rdtgrp); 3492fa7d9493SBabu Moger } else { 349319eb86a7SXiaochen Shen ret = rdtgroup_rmdir_ctrl(rdtgrp, tmpmask); 3494fa7d9493SBabu Moger } 3495fa7d9493SBabu Moger } else if (rdtgrp->type == RDTMON_GROUP && 3496fa7d9493SBabu Moger is_mon_groups(parent_kn, kn->name)) { 349719eb86a7SXiaochen Shen ret = rdtgroup_rmdir_mon(rdtgrp, tmpmask); 3498fa7d9493SBabu Moger } else { 3499fa7d9493SBabu Moger ret = -EPERM; 3500fa7d9493SBabu Moger } 3501fa7d9493SBabu Moger 3502fa7d9493SBabu Moger out: 3503fa7d9493SBabu Moger rdtgroup_kn_unlock(kn); 3504fa7d9493SBabu Moger free_cpumask_var(tmpmask); 3505fa7d9493SBabu Moger return ret; 3506fa7d9493SBabu Moger } 3507fa7d9493SBabu Moger 3508fa7d9493SBabu Moger static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf) 3509fa7d9493SBabu Moger { 3510c091e907SJames Morse if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3)) 3511fa7d9493SBabu Moger seq_puts(seq, ",cdp"); 3512fa7d9493SBabu Moger 3513c091e907SJames Morse if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) 3514fa7d9493SBabu Moger seq_puts(seq, ",cdpl2"); 3515fa7d9493SBabu Moger 351663c8b123SJames Morse if (is_mba_sc(&rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl)) 3517fa7d9493SBabu Moger seq_puts(seq, ",mba_MBps"); 3518fa7d9493SBabu Moger 3519fa7d9493SBabu Moger return 0; 3520fa7d9493SBabu Moger } 3521fa7d9493SBabu Moger 3522fa7d9493SBabu Moger static struct kernfs_syscall_ops rdtgroup_kf_syscall_ops = { 3523fa7d9493SBabu Moger .mkdir = rdtgroup_mkdir, 3524fa7d9493SBabu Moger .rmdir = rdtgroup_rmdir, 3525fa7d9493SBabu Moger .show_options = rdtgroup_show_options, 3526fa7d9493SBabu Moger }; 3527fa7d9493SBabu Moger 3528fa7d9493SBabu Moger static int __init rdtgroup_setup_root(void) 3529fa7d9493SBabu Moger { 3530fa7d9493SBabu Moger int ret; 3531fa7d9493SBabu Moger 3532fa7d9493SBabu Moger rdt_root = kernfs_create_root(&rdtgroup_kf_syscall_ops, 3533fa7d9493SBabu Moger KERNFS_ROOT_CREATE_DEACTIVATED | 3534fa7d9493SBabu Moger KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK, 3535fa7d9493SBabu Moger &rdtgroup_default); 3536fa7d9493SBabu Moger if (IS_ERR(rdt_root)) 3537fa7d9493SBabu Moger return PTR_ERR(rdt_root); 3538fa7d9493SBabu Moger 3539fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 3540fa7d9493SBabu Moger 3541fa7d9493SBabu Moger rdtgroup_default.closid = 0; 3542fa7d9493SBabu Moger rdtgroup_default.mon.rmid = 0; 3543fa7d9493SBabu Moger rdtgroup_default.type = RDTCTRL_GROUP; 3544fa7d9493SBabu Moger INIT_LIST_HEAD(&rdtgroup_default.mon.crdtgrp_list); 3545fa7d9493SBabu Moger 3546fa7d9493SBabu Moger list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups); 3547fa7d9493SBabu Moger 3548f2eb478fSGreg Kroah-Hartman ret = rdtgroup_add_files(kernfs_root_to_node(rdt_root), RF_CTRL_BASE); 3549fa7d9493SBabu Moger if (ret) { 3550fa7d9493SBabu Moger kernfs_destroy_root(rdt_root); 3551fa7d9493SBabu Moger goto out; 3552fa7d9493SBabu Moger } 3553fa7d9493SBabu Moger 3554f2eb478fSGreg Kroah-Hartman rdtgroup_default.kn = kernfs_root_to_node(rdt_root); 3555fa7d9493SBabu Moger kernfs_activate(rdtgroup_default.kn); 3556fa7d9493SBabu Moger 3557fa7d9493SBabu Moger out: 3558fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 3559fa7d9493SBabu Moger 3560fa7d9493SBabu Moger return ret; 3561fa7d9493SBabu Moger } 3562fa7d9493SBabu Moger 3563798fd4b9SJames Morse static void domain_destroy_mon_state(struct rdt_domain *d) 3564798fd4b9SJames Morse { 3565798fd4b9SJames Morse bitmap_free(d->rmid_busy_llc); 3566798fd4b9SJames Morse kfree(d->mbm_total); 3567798fd4b9SJames Morse kfree(d->mbm_local); 3568798fd4b9SJames Morse } 3569798fd4b9SJames Morse 3570798fd4b9SJames Morse void resctrl_offline_domain(struct rdt_resource *r, struct rdt_domain *d) 3571798fd4b9SJames Morse { 3572798fd4b9SJames Morse lockdep_assert_held(&rdtgroup_mutex); 3573798fd4b9SJames Morse 3574781096d9SJames Morse if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) 3575781096d9SJames Morse mba_sc_domain_destroy(r, d); 3576781096d9SJames Morse 3577798fd4b9SJames Morse if (!r->mon_capable) 3578798fd4b9SJames Morse return; 3579798fd4b9SJames Morse 3580798fd4b9SJames Morse /* 3581798fd4b9SJames Morse * If resctrl is mounted, remove all the 3582798fd4b9SJames Morse * per domain monitor data directories. 3583798fd4b9SJames Morse */ 3584798fd4b9SJames Morse if (static_branch_unlikely(&rdt_mon_enable_key)) 3585798fd4b9SJames Morse rmdir_mondata_subdir_allrdtgrp(r, d->id); 3586798fd4b9SJames Morse 3587798fd4b9SJames Morse if (is_mbm_enabled()) 3588798fd4b9SJames Morse cancel_delayed_work(&d->mbm_over); 3589798fd4b9SJames Morse if (is_llc_occupancy_enabled() && has_busy_rmid(r, d)) { 3590798fd4b9SJames Morse /* 3591798fd4b9SJames Morse * When a package is going down, forcefully 3592798fd4b9SJames Morse * decrement rmid->ebusy. There is no way to know 3593798fd4b9SJames Morse * that the L3 was flushed and hence may lead to 3594798fd4b9SJames Morse * incorrect counts in rare scenarios, but leaving 3595798fd4b9SJames Morse * the RMID as busy creates RMID leaks if the 3596798fd4b9SJames Morse * package never comes back. 3597798fd4b9SJames Morse */ 3598798fd4b9SJames Morse __check_limbo(d, true); 3599798fd4b9SJames Morse cancel_delayed_work(&d->cqm_limbo); 3600798fd4b9SJames Morse } 3601798fd4b9SJames Morse 3602798fd4b9SJames Morse domain_destroy_mon_state(d); 3603798fd4b9SJames Morse } 3604798fd4b9SJames Morse 36053a7232cdSJames Morse static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_domain *d) 36063a7232cdSJames Morse { 36073a7232cdSJames Morse size_t tsize; 36083a7232cdSJames Morse 36093a7232cdSJames Morse if (is_llc_occupancy_enabled()) { 36103a7232cdSJames Morse d->rmid_busy_llc = bitmap_zalloc(r->num_rmid, GFP_KERNEL); 36113a7232cdSJames Morse if (!d->rmid_busy_llc) 36123a7232cdSJames Morse return -ENOMEM; 36133a7232cdSJames Morse } 36143a7232cdSJames Morse if (is_mbm_total_enabled()) { 36153a7232cdSJames Morse tsize = sizeof(*d->mbm_total); 36163a7232cdSJames Morse d->mbm_total = kcalloc(r->num_rmid, tsize, GFP_KERNEL); 36173a7232cdSJames Morse if (!d->mbm_total) { 36183a7232cdSJames Morse bitmap_free(d->rmid_busy_llc); 36193a7232cdSJames Morse return -ENOMEM; 36203a7232cdSJames Morse } 36213a7232cdSJames Morse } 36223a7232cdSJames Morse if (is_mbm_local_enabled()) { 36233a7232cdSJames Morse tsize = sizeof(*d->mbm_local); 36243a7232cdSJames Morse d->mbm_local = kcalloc(r->num_rmid, tsize, GFP_KERNEL); 36253a7232cdSJames Morse if (!d->mbm_local) { 36263a7232cdSJames Morse bitmap_free(d->rmid_busy_llc); 36273a7232cdSJames Morse kfree(d->mbm_total); 36283a7232cdSJames Morse return -ENOMEM; 36293a7232cdSJames Morse } 36303a7232cdSJames Morse } 36313a7232cdSJames Morse 36323a7232cdSJames Morse return 0; 36333a7232cdSJames Morse } 36343a7232cdSJames Morse 36353a7232cdSJames Morse int resctrl_online_domain(struct rdt_resource *r, struct rdt_domain *d) 36363a7232cdSJames Morse { 36373a7232cdSJames Morse int err; 36383a7232cdSJames Morse 36393a7232cdSJames Morse lockdep_assert_held(&rdtgroup_mutex); 36403a7232cdSJames Morse 3641781096d9SJames Morse if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) 3642781096d9SJames Morse /* RDT_RESOURCE_MBA is never mon_capable */ 3643781096d9SJames Morse return mba_sc_domain_allocate(r, d); 3644781096d9SJames Morse 36453a7232cdSJames Morse if (!r->mon_capable) 36463a7232cdSJames Morse return 0; 36473a7232cdSJames Morse 36483a7232cdSJames Morse err = domain_setup_mon_state(r, d); 36493a7232cdSJames Morse if (err) 36503a7232cdSJames Morse return err; 36513a7232cdSJames Morse 36523a7232cdSJames Morse if (is_mbm_enabled()) { 36533a7232cdSJames Morse INIT_DELAYED_WORK(&d->mbm_over, mbm_handle_overflow); 36543a7232cdSJames Morse mbm_setup_overflow_handler(d, MBM_OVERFLOW_INTERVAL); 36553a7232cdSJames Morse } 36563a7232cdSJames Morse 36573a7232cdSJames Morse if (is_llc_occupancy_enabled()) 36583a7232cdSJames Morse INIT_DELAYED_WORK(&d->cqm_limbo, cqm_handle_limbo); 36593a7232cdSJames Morse 36603a7232cdSJames Morse /* If resctrl is mounted, add per domain monitor data directories. */ 36613a7232cdSJames Morse if (static_branch_unlikely(&rdt_mon_enable_key)) 36623a7232cdSJames Morse mkdir_mondata_subdir_allrdtgrp(r, d); 36633a7232cdSJames Morse 36643a7232cdSJames Morse return 0; 36653a7232cdSJames Morse } 36663a7232cdSJames Morse 3667fa7d9493SBabu Moger /* 3668fa7d9493SBabu Moger * rdtgroup_init - rdtgroup initialization 3669fa7d9493SBabu Moger * 3670fa7d9493SBabu Moger * Setup resctrl file system including set up root, create mount point, 3671fa7d9493SBabu Moger * register rdtgroup filesystem, and initialize files under root directory. 3672fa7d9493SBabu Moger * 3673fa7d9493SBabu Moger * Return: 0 on success or -errno 3674fa7d9493SBabu Moger */ 3675fa7d9493SBabu Moger int __init rdtgroup_init(void) 3676fa7d9493SBabu Moger { 3677fa7d9493SBabu Moger int ret = 0; 3678fa7d9493SBabu Moger 3679fa7d9493SBabu Moger seq_buf_init(&last_cmd_status, last_cmd_status_buf, 3680fa7d9493SBabu Moger sizeof(last_cmd_status_buf)); 3681fa7d9493SBabu Moger 3682fa7d9493SBabu Moger ret = rdtgroup_setup_root(); 3683fa7d9493SBabu Moger if (ret) 3684fa7d9493SBabu Moger return ret; 3685fa7d9493SBabu Moger 3686fa7d9493SBabu Moger ret = sysfs_create_mount_point(fs_kobj, "resctrl"); 3687fa7d9493SBabu Moger if (ret) 3688fa7d9493SBabu Moger goto cleanup_root; 3689fa7d9493SBabu Moger 3690fa7d9493SBabu Moger ret = register_filesystem(&rdt_fs_type); 3691fa7d9493SBabu Moger if (ret) 3692fa7d9493SBabu Moger goto cleanup_mountpoint; 3693fa7d9493SBabu Moger 3694fa7d9493SBabu Moger /* 3695fa7d9493SBabu Moger * Adding the resctrl debugfs directory here may not be ideal since 3696fa7d9493SBabu Moger * it would let the resctrl debugfs directory appear on the debugfs 3697fa7d9493SBabu Moger * filesystem before the resctrl filesystem is mounted. 3698fa7d9493SBabu Moger * It may also be ok since that would enable debugging of RDT before 3699fa7d9493SBabu Moger * resctrl is mounted. 3700fa7d9493SBabu Moger * The reason why the debugfs directory is created here and not in 3701ae0fbeddSJames Morse * rdt_get_tree() is because rdt_get_tree() takes rdtgroup_mutex and 3702fa7d9493SBabu Moger * during the debugfs directory creation also &sb->s_type->i_mutex_key 3703fa7d9493SBabu Moger * (the lockdep class of inode->i_rwsem). Other filesystem 3704fa7d9493SBabu Moger * interactions (eg. SyS_getdents) have the lock ordering: 3705c1e8d7c6SMichel Lespinasse * &sb->s_type->i_mutex_key --> &mm->mmap_lock 3706c1e8d7c6SMichel Lespinasse * During mmap(), called with &mm->mmap_lock, the rdtgroup_mutex 3707fa7d9493SBabu Moger * is taken, thus creating dependency: 3708c1e8d7c6SMichel Lespinasse * &mm->mmap_lock --> rdtgroup_mutex for the latter that can cause 3709fa7d9493SBabu Moger * issues considering the other two lock dependencies. 3710fa7d9493SBabu Moger * By creating the debugfs directory here we avoid a dependency 3711fa7d9493SBabu Moger * that may cause deadlock (even though file operations cannot 3712fa7d9493SBabu Moger * occur until the filesystem is mounted, but I do not know how to 3713fa7d9493SBabu Moger * tell lockdep that). 3714fa7d9493SBabu Moger */ 3715fa7d9493SBabu Moger debugfs_resctrl = debugfs_create_dir("resctrl", NULL); 3716fa7d9493SBabu Moger 3717fa7d9493SBabu Moger return 0; 3718fa7d9493SBabu Moger 3719fa7d9493SBabu Moger cleanup_mountpoint: 3720fa7d9493SBabu Moger sysfs_remove_mount_point(fs_kobj, "resctrl"); 3721fa7d9493SBabu Moger cleanup_root: 3722fa7d9493SBabu Moger kernfs_destroy_root(rdt_root); 3723fa7d9493SBabu Moger 3724fa7d9493SBabu Moger return ret; 3725fa7d9493SBabu Moger } 3726fa7d9493SBabu Moger 3727fa7d9493SBabu Moger void __exit rdtgroup_exit(void) 3728fa7d9493SBabu Moger { 3729fa7d9493SBabu Moger debugfs_remove_recursive(debugfs_resctrl); 3730fa7d9493SBabu Moger unregister_filesystem(&rdt_fs_type); 3731fa7d9493SBabu Moger sysfs_remove_mount_point(fs_kobj, "resctrl"); 3732fa7d9493SBabu Moger kernfs_destroy_root(rdt_root); 3733fa7d9493SBabu Moger } 3734