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 42*cdb9ebc9SJames Morse /* list of entries for the schemata file */ 43*cdb9ebc9SJames Morse LIST_HEAD(resctrl_schema_all); 44*cdb9ebc9SJames 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 81fa7d9493SBabu Moger /* 82fa7d9493SBabu Moger * Trivial allocator for CLOSIDs. Since h/w only supports a small number, 83fa7d9493SBabu Moger * we can keep a bitmap of free CLOSIDs in a single integer. 84fa7d9493SBabu Moger * 85fa7d9493SBabu Moger * Using a global CLOSID across all resources has some advantages and 86fa7d9493SBabu Moger * some drawbacks: 87fa7d9493SBabu Moger * + We can simply set "current->closid" to assign a task to a resource 88fa7d9493SBabu Moger * group. 89fa7d9493SBabu Moger * + Context switch code can avoid extra memory references deciding which 90fa7d9493SBabu Moger * CLOSID to load into the PQR_ASSOC MSR 91fa7d9493SBabu Moger * - We give up some options in configuring resource groups across multi-socket 92fa7d9493SBabu Moger * systems. 93fa7d9493SBabu Moger * - Our choices on how to configure each resource become progressively more 94fa7d9493SBabu Moger * limited as the number of resources grows. 95fa7d9493SBabu Moger */ 96fa7d9493SBabu Moger static int closid_free_map; 97fa7d9493SBabu Moger static int closid_free_map_len; 98fa7d9493SBabu Moger 99fa7d9493SBabu Moger int closids_supported(void) 100fa7d9493SBabu Moger { 101fa7d9493SBabu Moger return closid_free_map_len; 102fa7d9493SBabu Moger } 103fa7d9493SBabu Moger 104fa7d9493SBabu Moger static void closid_init(void) 105fa7d9493SBabu Moger { 10663c8b123SJames Morse struct rdt_hw_resource *hw_res; 107fa7d9493SBabu Moger struct rdt_resource *r; 108fa7d9493SBabu Moger int rdt_min_closid = 32; 109fa7d9493SBabu Moger 110fa7d9493SBabu Moger /* Compute rdt_min_closid across all resources */ 11163c8b123SJames Morse for_each_alloc_enabled_rdt_resource(r) { 11263c8b123SJames Morse hw_res = resctrl_to_arch_res(r); 11363c8b123SJames Morse rdt_min_closid = min(rdt_min_closid, hw_res->num_closid); 11463c8b123SJames Morse } 115fa7d9493SBabu Moger 116fa7d9493SBabu Moger closid_free_map = BIT_MASK(rdt_min_closid) - 1; 117fa7d9493SBabu Moger 118fa7d9493SBabu Moger /* CLOSID 0 is always reserved for the default group */ 119fa7d9493SBabu Moger closid_free_map &= ~1; 120fa7d9493SBabu Moger closid_free_map_len = rdt_min_closid; 121fa7d9493SBabu Moger } 122fa7d9493SBabu Moger 123fa7d9493SBabu Moger static int closid_alloc(void) 124fa7d9493SBabu Moger { 125fa7d9493SBabu Moger u32 closid = ffs(closid_free_map); 126fa7d9493SBabu Moger 127fa7d9493SBabu Moger if (closid == 0) 128fa7d9493SBabu Moger return -ENOSPC; 129fa7d9493SBabu Moger closid--; 130fa7d9493SBabu Moger closid_free_map &= ~(1 << closid); 131fa7d9493SBabu Moger 132fa7d9493SBabu Moger return closid; 133fa7d9493SBabu Moger } 134fa7d9493SBabu Moger 135fa7d9493SBabu Moger void closid_free(int closid) 136fa7d9493SBabu Moger { 137fa7d9493SBabu Moger closid_free_map |= 1 << closid; 138fa7d9493SBabu Moger } 139fa7d9493SBabu Moger 140fa7d9493SBabu Moger /** 141fa7d9493SBabu Moger * closid_allocated - test if provided closid is in use 142fa7d9493SBabu Moger * @closid: closid to be tested 143fa7d9493SBabu Moger * 144fa7d9493SBabu Moger * Return: true if @closid is currently associated with a resource group, 145fa7d9493SBabu Moger * false if @closid is free 146fa7d9493SBabu Moger */ 147fa7d9493SBabu Moger static bool closid_allocated(unsigned int closid) 148fa7d9493SBabu Moger { 149fa7d9493SBabu Moger return (closid_free_map & (1 << closid)) == 0; 150fa7d9493SBabu Moger } 151fa7d9493SBabu Moger 152fa7d9493SBabu Moger /** 153fa7d9493SBabu Moger * rdtgroup_mode_by_closid - Return mode of resource group with closid 154fa7d9493SBabu Moger * @closid: closid if the resource group 155fa7d9493SBabu Moger * 156fa7d9493SBabu Moger * Each resource group is associated with a @closid. Here the mode 157fa7d9493SBabu Moger * of a resource group can be queried by searching for it using its closid. 158fa7d9493SBabu Moger * 159fa7d9493SBabu Moger * Return: mode as &enum rdtgrp_mode of resource group with closid @closid 160fa7d9493SBabu Moger */ 161fa7d9493SBabu Moger enum rdtgrp_mode rdtgroup_mode_by_closid(int closid) 162fa7d9493SBabu Moger { 163fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 164fa7d9493SBabu Moger 165fa7d9493SBabu Moger list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 166fa7d9493SBabu Moger if (rdtgrp->closid == closid) 167fa7d9493SBabu Moger return rdtgrp->mode; 168fa7d9493SBabu Moger } 169fa7d9493SBabu Moger 170fa7d9493SBabu Moger return RDT_NUM_MODES; 171fa7d9493SBabu Moger } 172fa7d9493SBabu Moger 173fa7d9493SBabu Moger static const char * const rdt_mode_str[] = { 174fa7d9493SBabu Moger [RDT_MODE_SHAREABLE] = "shareable", 175fa7d9493SBabu Moger [RDT_MODE_EXCLUSIVE] = "exclusive", 176fa7d9493SBabu Moger [RDT_MODE_PSEUDO_LOCKSETUP] = "pseudo-locksetup", 177fa7d9493SBabu Moger [RDT_MODE_PSEUDO_LOCKED] = "pseudo-locked", 178fa7d9493SBabu Moger }; 179fa7d9493SBabu Moger 180fa7d9493SBabu Moger /** 181fa7d9493SBabu Moger * rdtgroup_mode_str - Return the string representation of mode 182fa7d9493SBabu Moger * @mode: the resource group mode as &enum rdtgroup_mode 183fa7d9493SBabu Moger * 184fa7d9493SBabu Moger * Return: string representation of valid mode, "unknown" otherwise 185fa7d9493SBabu Moger */ 186fa7d9493SBabu Moger static const char *rdtgroup_mode_str(enum rdtgrp_mode mode) 187fa7d9493SBabu Moger { 188fa7d9493SBabu Moger if (mode < RDT_MODE_SHAREABLE || mode >= RDT_NUM_MODES) 189fa7d9493SBabu Moger return "unknown"; 190fa7d9493SBabu Moger 191fa7d9493SBabu Moger return rdt_mode_str[mode]; 192fa7d9493SBabu Moger } 193fa7d9493SBabu Moger 194fa7d9493SBabu Moger /* set uid and gid of rdtgroup dirs and files to that of the creator */ 195fa7d9493SBabu Moger static int rdtgroup_kn_set_ugid(struct kernfs_node *kn) 196fa7d9493SBabu Moger { 197fa7d9493SBabu Moger struct iattr iattr = { .ia_valid = ATTR_UID | ATTR_GID, 198fa7d9493SBabu Moger .ia_uid = current_fsuid(), 199fa7d9493SBabu Moger .ia_gid = current_fsgid(), }; 200fa7d9493SBabu Moger 201fa7d9493SBabu Moger if (uid_eq(iattr.ia_uid, GLOBAL_ROOT_UID) && 202fa7d9493SBabu Moger gid_eq(iattr.ia_gid, GLOBAL_ROOT_GID)) 203fa7d9493SBabu Moger return 0; 204fa7d9493SBabu Moger 205fa7d9493SBabu Moger return kernfs_setattr(kn, &iattr); 206fa7d9493SBabu Moger } 207fa7d9493SBabu Moger 208fa7d9493SBabu Moger static int rdtgroup_add_file(struct kernfs_node *parent_kn, struct rftype *rft) 209fa7d9493SBabu Moger { 210fa7d9493SBabu Moger struct kernfs_node *kn; 211fa7d9493SBabu Moger int ret; 212fa7d9493SBabu Moger 213fa7d9493SBabu Moger kn = __kernfs_create_file(parent_kn, rft->name, rft->mode, 214fa7d9493SBabu Moger GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 215fa7d9493SBabu Moger 0, rft->kf_ops, rft, NULL, NULL); 216fa7d9493SBabu Moger if (IS_ERR(kn)) 217fa7d9493SBabu Moger return PTR_ERR(kn); 218fa7d9493SBabu Moger 219fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 220fa7d9493SBabu Moger if (ret) { 221fa7d9493SBabu Moger kernfs_remove(kn); 222fa7d9493SBabu Moger return ret; 223fa7d9493SBabu Moger } 224fa7d9493SBabu Moger 225fa7d9493SBabu Moger return 0; 226fa7d9493SBabu Moger } 227fa7d9493SBabu Moger 228fa7d9493SBabu Moger static int rdtgroup_seqfile_show(struct seq_file *m, void *arg) 229fa7d9493SBabu Moger { 230fa7d9493SBabu Moger struct kernfs_open_file *of = m->private; 231fa7d9493SBabu Moger struct rftype *rft = of->kn->priv; 232fa7d9493SBabu Moger 233fa7d9493SBabu Moger if (rft->seq_show) 234fa7d9493SBabu Moger return rft->seq_show(of, m, arg); 235fa7d9493SBabu Moger return 0; 236fa7d9493SBabu Moger } 237fa7d9493SBabu Moger 238fa7d9493SBabu Moger static ssize_t rdtgroup_file_write(struct kernfs_open_file *of, char *buf, 239fa7d9493SBabu Moger size_t nbytes, loff_t off) 240fa7d9493SBabu Moger { 241fa7d9493SBabu Moger struct rftype *rft = of->kn->priv; 242fa7d9493SBabu Moger 243fa7d9493SBabu Moger if (rft->write) 244fa7d9493SBabu Moger return rft->write(of, buf, nbytes, off); 245fa7d9493SBabu Moger 246fa7d9493SBabu Moger return -EINVAL; 247fa7d9493SBabu Moger } 248fa7d9493SBabu Moger 2492002d295SRikard Falkeborn static const struct kernfs_ops rdtgroup_kf_single_ops = { 250fa7d9493SBabu Moger .atomic_write_len = PAGE_SIZE, 251fa7d9493SBabu Moger .write = rdtgroup_file_write, 252fa7d9493SBabu Moger .seq_show = rdtgroup_seqfile_show, 253fa7d9493SBabu Moger }; 254fa7d9493SBabu Moger 2552002d295SRikard Falkeborn static const struct kernfs_ops kf_mondata_ops = { 256fa7d9493SBabu Moger .atomic_write_len = PAGE_SIZE, 257fa7d9493SBabu Moger .seq_show = rdtgroup_mondata_show, 258fa7d9493SBabu Moger }; 259fa7d9493SBabu Moger 260fa7d9493SBabu Moger static bool is_cpu_list(struct kernfs_open_file *of) 261fa7d9493SBabu Moger { 262fa7d9493SBabu Moger struct rftype *rft = of->kn->priv; 263fa7d9493SBabu Moger 264fa7d9493SBabu Moger return rft->flags & RFTYPE_FLAGS_CPUS_LIST; 265fa7d9493SBabu Moger } 266fa7d9493SBabu Moger 267fa7d9493SBabu Moger static int rdtgroup_cpus_show(struct kernfs_open_file *of, 268fa7d9493SBabu Moger struct seq_file *s, void *v) 269fa7d9493SBabu Moger { 270fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 271fa7d9493SBabu Moger struct cpumask *mask; 272fa7d9493SBabu Moger int ret = 0; 273fa7d9493SBabu Moger 274fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 275fa7d9493SBabu Moger 276fa7d9493SBabu Moger if (rdtgrp) { 277fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 278fa7d9493SBabu Moger if (!rdtgrp->plr->d) { 279fa7d9493SBabu Moger rdt_last_cmd_clear(); 280fa7d9493SBabu Moger rdt_last_cmd_puts("Cache domain offline\n"); 281fa7d9493SBabu Moger ret = -ENODEV; 282fa7d9493SBabu Moger } else { 283fa7d9493SBabu Moger mask = &rdtgrp->plr->d->cpu_mask; 284fa7d9493SBabu Moger seq_printf(s, is_cpu_list(of) ? 285fa7d9493SBabu Moger "%*pbl\n" : "%*pb\n", 286fa7d9493SBabu Moger cpumask_pr_args(mask)); 287fa7d9493SBabu Moger } 288fa7d9493SBabu Moger } else { 289fa7d9493SBabu Moger seq_printf(s, is_cpu_list(of) ? "%*pbl\n" : "%*pb\n", 290fa7d9493SBabu Moger cpumask_pr_args(&rdtgrp->cpu_mask)); 291fa7d9493SBabu Moger } 292fa7d9493SBabu Moger } else { 293fa7d9493SBabu Moger ret = -ENOENT; 294fa7d9493SBabu Moger } 295fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 296fa7d9493SBabu Moger 297fa7d9493SBabu Moger return ret; 298fa7d9493SBabu Moger } 299fa7d9493SBabu Moger 300fa7d9493SBabu Moger /* 301352940ecSBabu Moger * This is safe against resctrl_sched_in() called from __switch_to() 302fa7d9493SBabu Moger * because __switch_to() is executed with interrupts disabled. A local call 303d9f6e12fSIngo Molnar * from update_closid_rmid() is protected against __switch_to() because 304fa7d9493SBabu Moger * preemption is disabled. 305fa7d9493SBabu Moger */ 306fa7d9493SBabu Moger static void update_cpu_closid_rmid(void *info) 307fa7d9493SBabu Moger { 308fa7d9493SBabu Moger struct rdtgroup *r = info; 309fa7d9493SBabu Moger 310fa7d9493SBabu Moger if (r) { 311fa7d9493SBabu Moger this_cpu_write(pqr_state.default_closid, r->closid); 312fa7d9493SBabu Moger this_cpu_write(pqr_state.default_rmid, r->mon.rmid); 313fa7d9493SBabu Moger } 314fa7d9493SBabu Moger 315fa7d9493SBabu Moger /* 316fa7d9493SBabu Moger * We cannot unconditionally write the MSR because the current 317fa7d9493SBabu Moger * executing task might have its own closid selected. Just reuse 318fa7d9493SBabu Moger * the context switch code. 319fa7d9493SBabu Moger */ 320352940ecSBabu Moger resctrl_sched_in(); 321fa7d9493SBabu Moger } 322fa7d9493SBabu Moger 323fa7d9493SBabu Moger /* 324fa7d9493SBabu Moger * Update the PGR_ASSOC MSR on all cpus in @cpu_mask, 325fa7d9493SBabu Moger * 326fa7d9493SBabu Moger * Per task closids/rmids must have been set up before calling this function. 327fa7d9493SBabu Moger */ 328fa7d9493SBabu Moger static void 329fa7d9493SBabu Moger update_closid_rmid(const struct cpumask *cpu_mask, struct rdtgroup *r) 330fa7d9493SBabu Moger { 331fa7d9493SBabu Moger int cpu = get_cpu(); 332fa7d9493SBabu Moger 333fa7d9493SBabu Moger if (cpumask_test_cpu(cpu, cpu_mask)) 334fa7d9493SBabu Moger update_cpu_closid_rmid(r); 335fa7d9493SBabu Moger smp_call_function_many(cpu_mask, update_cpu_closid_rmid, r, 1); 336fa7d9493SBabu Moger put_cpu(); 337fa7d9493SBabu Moger } 338fa7d9493SBabu Moger 339fa7d9493SBabu Moger static int cpus_mon_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 340fa7d9493SBabu Moger cpumask_var_t tmpmask) 341fa7d9493SBabu Moger { 342fa7d9493SBabu Moger struct rdtgroup *prgrp = rdtgrp->mon.parent, *crgrp; 343fa7d9493SBabu Moger struct list_head *head; 344fa7d9493SBabu Moger 345fa7d9493SBabu Moger /* Check whether cpus belong to parent ctrl group */ 346fa7d9493SBabu Moger cpumask_andnot(tmpmask, newmask, &prgrp->cpu_mask); 347fa7d9493SBabu Moger if (cpumask_weight(tmpmask)) { 348723f1a0dSBabu Moger rdt_last_cmd_puts("Can only add CPUs to mongroup that belong to parent\n"); 349fa7d9493SBabu Moger return -EINVAL; 350fa7d9493SBabu Moger } 351fa7d9493SBabu Moger 352fa7d9493SBabu Moger /* Check whether cpus are dropped from this group */ 353fa7d9493SBabu Moger cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 354fa7d9493SBabu Moger if (cpumask_weight(tmpmask)) { 355fa7d9493SBabu Moger /* Give any dropped cpus to parent rdtgroup */ 356fa7d9493SBabu Moger cpumask_or(&prgrp->cpu_mask, &prgrp->cpu_mask, tmpmask); 357fa7d9493SBabu Moger update_closid_rmid(tmpmask, prgrp); 358fa7d9493SBabu Moger } 359fa7d9493SBabu Moger 360fa7d9493SBabu Moger /* 361fa7d9493SBabu Moger * If we added cpus, remove them from previous group that owned them 362fa7d9493SBabu Moger * and update per-cpu rmid 363fa7d9493SBabu Moger */ 364fa7d9493SBabu Moger cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 365fa7d9493SBabu Moger if (cpumask_weight(tmpmask)) { 366fa7d9493SBabu Moger head = &prgrp->mon.crdtgrp_list; 367fa7d9493SBabu Moger list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 368fa7d9493SBabu Moger if (crgrp == rdtgrp) 369fa7d9493SBabu Moger continue; 370fa7d9493SBabu Moger cpumask_andnot(&crgrp->cpu_mask, &crgrp->cpu_mask, 371fa7d9493SBabu Moger tmpmask); 372fa7d9493SBabu Moger } 373fa7d9493SBabu Moger update_closid_rmid(tmpmask, rdtgrp); 374fa7d9493SBabu Moger } 375fa7d9493SBabu Moger 376fa7d9493SBabu Moger /* Done pushing/pulling - update this group with new mask */ 377fa7d9493SBabu Moger cpumask_copy(&rdtgrp->cpu_mask, newmask); 378fa7d9493SBabu Moger 379fa7d9493SBabu Moger return 0; 380fa7d9493SBabu Moger } 381fa7d9493SBabu Moger 382fa7d9493SBabu Moger static void cpumask_rdtgrp_clear(struct rdtgroup *r, struct cpumask *m) 383fa7d9493SBabu Moger { 384fa7d9493SBabu Moger struct rdtgroup *crgrp; 385fa7d9493SBabu Moger 386fa7d9493SBabu Moger cpumask_andnot(&r->cpu_mask, &r->cpu_mask, m); 387fa7d9493SBabu Moger /* update the child mon group masks as well*/ 388fa7d9493SBabu Moger list_for_each_entry(crgrp, &r->mon.crdtgrp_list, mon.crdtgrp_list) 389fa7d9493SBabu Moger cpumask_and(&crgrp->cpu_mask, &r->cpu_mask, &crgrp->cpu_mask); 390fa7d9493SBabu Moger } 391fa7d9493SBabu Moger 392fa7d9493SBabu Moger static int cpus_ctrl_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 393fa7d9493SBabu Moger cpumask_var_t tmpmask, cpumask_var_t tmpmask1) 394fa7d9493SBabu Moger { 395fa7d9493SBabu Moger struct rdtgroup *r, *crgrp; 396fa7d9493SBabu Moger struct list_head *head; 397fa7d9493SBabu Moger 398fa7d9493SBabu Moger /* Check whether cpus are dropped from this group */ 399fa7d9493SBabu Moger cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 400fa7d9493SBabu Moger if (cpumask_weight(tmpmask)) { 401fa7d9493SBabu Moger /* Can't drop from default group */ 402fa7d9493SBabu Moger if (rdtgrp == &rdtgroup_default) { 403fa7d9493SBabu Moger rdt_last_cmd_puts("Can't drop CPUs from default group\n"); 404fa7d9493SBabu Moger return -EINVAL; 405fa7d9493SBabu Moger } 406fa7d9493SBabu Moger 407fa7d9493SBabu Moger /* Give any dropped cpus to rdtgroup_default */ 408fa7d9493SBabu Moger cpumask_or(&rdtgroup_default.cpu_mask, 409fa7d9493SBabu Moger &rdtgroup_default.cpu_mask, tmpmask); 410fa7d9493SBabu Moger update_closid_rmid(tmpmask, &rdtgroup_default); 411fa7d9493SBabu Moger } 412fa7d9493SBabu Moger 413fa7d9493SBabu Moger /* 414fa7d9493SBabu Moger * If we added cpus, remove them from previous group and 415fa7d9493SBabu Moger * the prev group's child groups that owned them 416fa7d9493SBabu Moger * and update per-cpu closid/rmid. 417fa7d9493SBabu Moger */ 418fa7d9493SBabu Moger cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 419fa7d9493SBabu Moger if (cpumask_weight(tmpmask)) { 420fa7d9493SBabu Moger list_for_each_entry(r, &rdt_all_groups, rdtgroup_list) { 421fa7d9493SBabu Moger if (r == rdtgrp) 422fa7d9493SBabu Moger continue; 423fa7d9493SBabu Moger cpumask_and(tmpmask1, &r->cpu_mask, tmpmask); 424fa7d9493SBabu Moger if (cpumask_weight(tmpmask1)) 425fa7d9493SBabu Moger cpumask_rdtgrp_clear(r, tmpmask1); 426fa7d9493SBabu Moger } 427fa7d9493SBabu Moger update_closid_rmid(tmpmask, rdtgrp); 428fa7d9493SBabu Moger } 429fa7d9493SBabu Moger 430fa7d9493SBabu Moger /* Done pushing/pulling - update this group with new mask */ 431fa7d9493SBabu Moger cpumask_copy(&rdtgrp->cpu_mask, newmask); 432fa7d9493SBabu Moger 433fa7d9493SBabu Moger /* 434fa7d9493SBabu Moger * Clear child mon group masks since there is a new parent mask 435fa7d9493SBabu Moger * now and update the rmid for the cpus the child lost. 436fa7d9493SBabu Moger */ 437fa7d9493SBabu Moger head = &rdtgrp->mon.crdtgrp_list; 438fa7d9493SBabu Moger list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 439fa7d9493SBabu Moger cpumask_and(tmpmask, &rdtgrp->cpu_mask, &crgrp->cpu_mask); 440fa7d9493SBabu Moger update_closid_rmid(tmpmask, rdtgrp); 441fa7d9493SBabu Moger cpumask_clear(&crgrp->cpu_mask); 442fa7d9493SBabu Moger } 443fa7d9493SBabu Moger 444fa7d9493SBabu Moger return 0; 445fa7d9493SBabu Moger } 446fa7d9493SBabu Moger 447fa7d9493SBabu Moger static ssize_t rdtgroup_cpus_write(struct kernfs_open_file *of, 448fa7d9493SBabu Moger char *buf, size_t nbytes, loff_t off) 449fa7d9493SBabu Moger { 450fa7d9493SBabu Moger cpumask_var_t tmpmask, newmask, tmpmask1; 451fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 452fa7d9493SBabu Moger int ret; 453fa7d9493SBabu Moger 454fa7d9493SBabu Moger if (!buf) 455fa7d9493SBabu Moger return -EINVAL; 456fa7d9493SBabu Moger 457fa7d9493SBabu Moger if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 458fa7d9493SBabu Moger return -ENOMEM; 459fa7d9493SBabu Moger if (!zalloc_cpumask_var(&newmask, GFP_KERNEL)) { 460fa7d9493SBabu Moger free_cpumask_var(tmpmask); 461fa7d9493SBabu Moger return -ENOMEM; 462fa7d9493SBabu Moger } 463fa7d9493SBabu Moger if (!zalloc_cpumask_var(&tmpmask1, GFP_KERNEL)) { 464fa7d9493SBabu Moger free_cpumask_var(tmpmask); 465fa7d9493SBabu Moger free_cpumask_var(newmask); 466fa7d9493SBabu Moger return -ENOMEM; 467fa7d9493SBabu Moger } 468fa7d9493SBabu Moger 469fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 470fa7d9493SBabu Moger if (!rdtgrp) { 471fa7d9493SBabu Moger ret = -ENOENT; 472fa7d9493SBabu Moger goto unlock; 473fa7d9493SBabu Moger } 474fa7d9493SBabu Moger 475fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 476fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 477fa7d9493SBabu Moger ret = -EINVAL; 478723f1a0dSBabu Moger rdt_last_cmd_puts("Pseudo-locking in progress\n"); 479fa7d9493SBabu Moger goto unlock; 480fa7d9493SBabu Moger } 481fa7d9493SBabu Moger 482fa7d9493SBabu Moger if (is_cpu_list(of)) 483fa7d9493SBabu Moger ret = cpulist_parse(buf, newmask); 484fa7d9493SBabu Moger else 485fa7d9493SBabu Moger ret = cpumask_parse(buf, newmask); 486fa7d9493SBabu Moger 487fa7d9493SBabu Moger if (ret) { 488723f1a0dSBabu Moger rdt_last_cmd_puts("Bad CPU list/mask\n"); 489fa7d9493SBabu Moger goto unlock; 490fa7d9493SBabu Moger } 491fa7d9493SBabu Moger 492fa7d9493SBabu Moger /* check that user didn't specify any offline cpus */ 493fa7d9493SBabu Moger cpumask_andnot(tmpmask, newmask, cpu_online_mask); 494fa7d9493SBabu Moger if (cpumask_weight(tmpmask)) { 495fa7d9493SBabu Moger ret = -EINVAL; 496723f1a0dSBabu Moger rdt_last_cmd_puts("Can only assign online CPUs\n"); 497fa7d9493SBabu Moger goto unlock; 498fa7d9493SBabu Moger } 499fa7d9493SBabu Moger 500fa7d9493SBabu Moger if (rdtgrp->type == RDTCTRL_GROUP) 501fa7d9493SBabu Moger ret = cpus_ctrl_write(rdtgrp, newmask, tmpmask, tmpmask1); 502fa7d9493SBabu Moger else if (rdtgrp->type == RDTMON_GROUP) 503fa7d9493SBabu Moger ret = cpus_mon_write(rdtgrp, newmask, tmpmask); 504fa7d9493SBabu Moger else 505fa7d9493SBabu Moger ret = -EINVAL; 506fa7d9493SBabu Moger 507fa7d9493SBabu Moger unlock: 508fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 509fa7d9493SBabu Moger free_cpumask_var(tmpmask); 510fa7d9493SBabu Moger free_cpumask_var(newmask); 511fa7d9493SBabu Moger free_cpumask_var(tmpmask1); 512fa7d9493SBabu Moger 513fa7d9493SBabu Moger return ret ?: nbytes; 514fa7d9493SBabu Moger } 515fa7d9493SBabu Moger 51675899924SXiaochen Shen /** 51775899924SXiaochen Shen * rdtgroup_remove - the helper to remove resource group safely 51875899924SXiaochen Shen * @rdtgrp: resource group to remove 51975899924SXiaochen Shen * 52075899924SXiaochen Shen * On resource group creation via a mkdir, an extra kernfs_node reference is 52175899924SXiaochen Shen * taken to ensure that the rdtgroup structure remains accessible for the 52275899924SXiaochen Shen * rdtgroup_kn_unlock() calls where it is removed. 52375899924SXiaochen Shen * 52475899924SXiaochen Shen * Drop the extra reference here, then free the rdtgroup structure. 52575899924SXiaochen Shen * 52675899924SXiaochen Shen * Return: void 52775899924SXiaochen Shen */ 52875899924SXiaochen Shen static void rdtgroup_remove(struct rdtgroup *rdtgrp) 52975899924SXiaochen Shen { 53075899924SXiaochen Shen kernfs_put(rdtgrp->kn); 53175899924SXiaochen Shen kfree(rdtgrp); 53275899924SXiaochen Shen } 53375899924SXiaochen Shen 534ae28d1aaSFenghua Yu static void _update_task_closid_rmid(void *task) 535fa7d9493SBabu Moger { 536fa7d9493SBabu Moger /* 537ae28d1aaSFenghua Yu * If the task is still current on this CPU, update PQR_ASSOC MSR. 538ae28d1aaSFenghua Yu * Otherwise, the MSR is updated when the task is scheduled in. 539fa7d9493SBabu Moger */ 540ae28d1aaSFenghua Yu if (task == current) 541ae28d1aaSFenghua Yu resctrl_sched_in(); 542fa7d9493SBabu Moger } 543fa7d9493SBabu Moger 544ae28d1aaSFenghua Yu static void update_task_closid_rmid(struct task_struct *t) 545ae28d1aaSFenghua Yu { 546ae28d1aaSFenghua Yu if (IS_ENABLED(CONFIG_SMP) && task_curr(t)) 547ae28d1aaSFenghua Yu smp_call_function_single(task_cpu(t), _update_task_closid_rmid, t, 1); 548ae28d1aaSFenghua Yu else 549ae28d1aaSFenghua Yu _update_task_closid_rmid(t); 550fa7d9493SBabu Moger } 551fa7d9493SBabu Moger 552fa7d9493SBabu Moger static int __rdtgroup_move_task(struct task_struct *tsk, 553fa7d9493SBabu Moger struct rdtgroup *rdtgrp) 554fa7d9493SBabu Moger { 555a0195f31SFenghua Yu /* If the task is already in rdtgrp, no need to move the task. */ 556a0195f31SFenghua Yu if ((rdtgrp->type == RDTCTRL_GROUP && tsk->closid == rdtgrp->closid && 557a0195f31SFenghua Yu tsk->rmid == rdtgrp->mon.rmid) || 558a0195f31SFenghua Yu (rdtgrp->type == RDTMON_GROUP && tsk->rmid == rdtgrp->mon.rmid && 559a0195f31SFenghua Yu tsk->closid == rdtgrp->mon.parent->closid)) 560a0195f31SFenghua Yu return 0; 561a0195f31SFenghua Yu 562fa7d9493SBabu Moger /* 563ae28d1aaSFenghua Yu * Set the task's closid/rmid before the PQR_ASSOC MSR can be 564ae28d1aaSFenghua Yu * updated by them. 565ae28d1aaSFenghua Yu * 566ae28d1aaSFenghua Yu * For ctrl_mon groups, move both closid and rmid. 567fa7d9493SBabu Moger * For monitor groups, can move the tasks only from 568fa7d9493SBabu Moger * their parent CTRL group. 569fa7d9493SBabu Moger */ 570ae28d1aaSFenghua Yu 571fa7d9493SBabu Moger if (rdtgrp->type == RDTCTRL_GROUP) { 5726d3b47ddSValentin Schneider WRITE_ONCE(tsk->closid, rdtgrp->closid); 5736d3b47ddSValentin Schneider WRITE_ONCE(tsk->rmid, rdtgrp->mon.rmid); 574fa7d9493SBabu Moger } else if (rdtgrp->type == RDTMON_GROUP) { 575fa7d9493SBabu Moger if (rdtgrp->mon.parent->closid == tsk->closid) { 5766d3b47ddSValentin Schneider WRITE_ONCE(tsk->rmid, rdtgrp->mon.rmid); 577fa7d9493SBabu Moger } else { 578fa7d9493SBabu Moger rdt_last_cmd_puts("Can't move task to different control group\n"); 579ae28d1aaSFenghua Yu return -EINVAL; 580fa7d9493SBabu Moger } 581fa7d9493SBabu Moger } 582ae28d1aaSFenghua Yu 583ae28d1aaSFenghua Yu /* 584ae28d1aaSFenghua Yu * Ensure the task's closid and rmid are written before determining if 585ae28d1aaSFenghua Yu * the task is current that will decide if it will be interrupted. 586ae28d1aaSFenghua Yu */ 587ae28d1aaSFenghua Yu barrier(); 588ae28d1aaSFenghua Yu 589ae28d1aaSFenghua Yu /* 590ae28d1aaSFenghua Yu * By now, the task's closid and rmid are set. If the task is current 591ae28d1aaSFenghua Yu * on a CPU, the PQR_ASSOC MSR needs to be updated to make the resource 592ae28d1aaSFenghua Yu * group go into effect. If the task is not current, the MSR will be 593ae28d1aaSFenghua Yu * updated when the task is scheduled in. 594ae28d1aaSFenghua Yu */ 595ae28d1aaSFenghua Yu update_task_closid_rmid(tsk); 596ae28d1aaSFenghua Yu 597ae28d1aaSFenghua Yu return 0; 598fa7d9493SBabu Moger } 599fa7d9493SBabu Moger 600e6b2fac3SJames Morse static bool is_closid_match(struct task_struct *t, struct rdtgroup *r) 601e6b2fac3SJames Morse { 602e6b2fac3SJames Morse return (rdt_alloc_capable && 603e6b2fac3SJames Morse (r->type == RDTCTRL_GROUP) && (t->closid == r->closid)); 604e6b2fac3SJames Morse } 605e6b2fac3SJames Morse 606e6b2fac3SJames Morse static bool is_rmid_match(struct task_struct *t, struct rdtgroup *r) 607e6b2fac3SJames Morse { 608e6b2fac3SJames Morse return (rdt_mon_capable && 609e6b2fac3SJames Morse (r->type == RDTMON_GROUP) && (t->rmid == r->mon.rmid)); 610e6b2fac3SJames Morse } 611e6b2fac3SJames Morse 612fa7d9493SBabu Moger /** 613fa7d9493SBabu Moger * rdtgroup_tasks_assigned - Test if tasks have been assigned to resource group 614fa7d9493SBabu Moger * @r: Resource group 615fa7d9493SBabu Moger * 616fa7d9493SBabu Moger * Return: 1 if tasks have been assigned to @r, 0 otherwise 617fa7d9493SBabu Moger */ 618fa7d9493SBabu Moger int rdtgroup_tasks_assigned(struct rdtgroup *r) 619fa7d9493SBabu Moger { 620fa7d9493SBabu Moger struct task_struct *p, *t; 621fa7d9493SBabu Moger int ret = 0; 622fa7d9493SBabu Moger 623fa7d9493SBabu Moger lockdep_assert_held(&rdtgroup_mutex); 624fa7d9493SBabu Moger 625fa7d9493SBabu Moger rcu_read_lock(); 626fa7d9493SBabu Moger for_each_process_thread(p, t) { 627e6b2fac3SJames Morse if (is_closid_match(t, r) || is_rmid_match(t, r)) { 628fa7d9493SBabu Moger ret = 1; 629fa7d9493SBabu Moger break; 630fa7d9493SBabu Moger } 631fa7d9493SBabu Moger } 632fa7d9493SBabu Moger rcu_read_unlock(); 633fa7d9493SBabu Moger 634fa7d9493SBabu Moger return ret; 635fa7d9493SBabu Moger } 636fa7d9493SBabu Moger 637fa7d9493SBabu Moger static int rdtgroup_task_write_permission(struct task_struct *task, 638fa7d9493SBabu Moger struct kernfs_open_file *of) 639fa7d9493SBabu Moger { 640fa7d9493SBabu Moger const struct cred *tcred = get_task_cred(task); 641fa7d9493SBabu Moger const struct cred *cred = current_cred(); 642fa7d9493SBabu Moger int ret = 0; 643fa7d9493SBabu Moger 644fa7d9493SBabu Moger /* 645fa7d9493SBabu Moger * Even if we're attaching all tasks in the thread group, we only 646fa7d9493SBabu Moger * need to check permissions on one of them. 647fa7d9493SBabu Moger */ 648fa7d9493SBabu Moger if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) && 649fa7d9493SBabu Moger !uid_eq(cred->euid, tcred->uid) && 650fa7d9493SBabu Moger !uid_eq(cred->euid, tcred->suid)) { 651fa7d9493SBabu Moger rdt_last_cmd_printf("No permission to move task %d\n", task->pid); 652fa7d9493SBabu Moger ret = -EPERM; 653fa7d9493SBabu Moger } 654fa7d9493SBabu Moger 655fa7d9493SBabu Moger put_cred(tcred); 656fa7d9493SBabu Moger return ret; 657fa7d9493SBabu Moger } 658fa7d9493SBabu Moger 659fa7d9493SBabu Moger static int rdtgroup_move_task(pid_t pid, struct rdtgroup *rdtgrp, 660fa7d9493SBabu Moger struct kernfs_open_file *of) 661fa7d9493SBabu Moger { 662fa7d9493SBabu Moger struct task_struct *tsk; 663fa7d9493SBabu Moger int ret; 664fa7d9493SBabu Moger 665fa7d9493SBabu Moger rcu_read_lock(); 666fa7d9493SBabu Moger if (pid) { 667fa7d9493SBabu Moger tsk = find_task_by_vpid(pid); 668fa7d9493SBabu Moger if (!tsk) { 669fa7d9493SBabu Moger rcu_read_unlock(); 670fa7d9493SBabu Moger rdt_last_cmd_printf("No task %d\n", pid); 671fa7d9493SBabu Moger return -ESRCH; 672fa7d9493SBabu Moger } 673fa7d9493SBabu Moger } else { 674fa7d9493SBabu Moger tsk = current; 675fa7d9493SBabu Moger } 676fa7d9493SBabu Moger 677fa7d9493SBabu Moger get_task_struct(tsk); 678fa7d9493SBabu Moger rcu_read_unlock(); 679fa7d9493SBabu Moger 680fa7d9493SBabu Moger ret = rdtgroup_task_write_permission(tsk, of); 681fa7d9493SBabu Moger if (!ret) 682fa7d9493SBabu Moger ret = __rdtgroup_move_task(tsk, rdtgrp); 683fa7d9493SBabu Moger 684fa7d9493SBabu Moger put_task_struct(tsk); 685fa7d9493SBabu Moger return ret; 686fa7d9493SBabu Moger } 687fa7d9493SBabu Moger 688fa7d9493SBabu Moger static ssize_t rdtgroup_tasks_write(struct kernfs_open_file *of, 689fa7d9493SBabu Moger char *buf, size_t nbytes, loff_t off) 690fa7d9493SBabu Moger { 691fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 692fa7d9493SBabu Moger int ret = 0; 693fa7d9493SBabu Moger pid_t pid; 694fa7d9493SBabu Moger 695fa7d9493SBabu Moger if (kstrtoint(strstrip(buf), 0, &pid) || pid < 0) 696fa7d9493SBabu Moger return -EINVAL; 697fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 698fa7d9493SBabu Moger if (!rdtgrp) { 699fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 700fa7d9493SBabu Moger return -ENOENT; 701fa7d9493SBabu Moger } 702fa7d9493SBabu Moger rdt_last_cmd_clear(); 703fa7d9493SBabu Moger 704fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 705fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 706fa7d9493SBabu Moger ret = -EINVAL; 707723f1a0dSBabu Moger rdt_last_cmd_puts("Pseudo-locking in progress\n"); 708fa7d9493SBabu Moger goto unlock; 709fa7d9493SBabu Moger } 710fa7d9493SBabu Moger 711fa7d9493SBabu Moger ret = rdtgroup_move_task(pid, rdtgrp, of); 712fa7d9493SBabu Moger 713fa7d9493SBabu Moger unlock: 714fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 715fa7d9493SBabu Moger 716fa7d9493SBabu Moger return ret ?: nbytes; 717fa7d9493SBabu Moger } 718fa7d9493SBabu Moger 719fa7d9493SBabu Moger static void show_rdt_tasks(struct rdtgroup *r, struct seq_file *s) 720fa7d9493SBabu Moger { 721fa7d9493SBabu Moger struct task_struct *p, *t; 722fa7d9493SBabu Moger 723fa7d9493SBabu Moger rcu_read_lock(); 724fa7d9493SBabu Moger for_each_process_thread(p, t) { 725e6b2fac3SJames Morse if (is_closid_match(t, r) || is_rmid_match(t, r)) 726fa7d9493SBabu Moger seq_printf(s, "%d\n", t->pid); 727fa7d9493SBabu Moger } 728fa7d9493SBabu Moger rcu_read_unlock(); 729fa7d9493SBabu Moger } 730fa7d9493SBabu Moger 731fa7d9493SBabu Moger static int rdtgroup_tasks_show(struct kernfs_open_file *of, 732fa7d9493SBabu Moger struct seq_file *s, void *v) 733fa7d9493SBabu Moger { 734fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 735fa7d9493SBabu Moger int ret = 0; 736fa7d9493SBabu Moger 737fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 738fa7d9493SBabu Moger if (rdtgrp) 739fa7d9493SBabu Moger show_rdt_tasks(rdtgrp, s); 740fa7d9493SBabu Moger else 741fa7d9493SBabu Moger ret = -ENOENT; 742fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 743fa7d9493SBabu Moger 744fa7d9493SBabu Moger return ret; 745fa7d9493SBabu Moger } 746fa7d9493SBabu Moger 747e79f15a4SChen Yu #ifdef CONFIG_PROC_CPU_RESCTRL 748e79f15a4SChen Yu 749e79f15a4SChen Yu /* 750e79f15a4SChen Yu * A task can only be part of one resctrl control group and of one monitor 751e79f15a4SChen Yu * group which is associated to that control group. 752e79f15a4SChen Yu * 753e79f15a4SChen Yu * 1) res: 754e79f15a4SChen Yu * mon: 755e79f15a4SChen Yu * 756e79f15a4SChen Yu * resctrl is not available. 757e79f15a4SChen Yu * 758e79f15a4SChen Yu * 2) res:/ 759e79f15a4SChen Yu * mon: 760e79f15a4SChen Yu * 761e79f15a4SChen Yu * Task is part of the root resctrl control group, and it is not associated 762e79f15a4SChen Yu * to any monitor group. 763e79f15a4SChen Yu * 764e79f15a4SChen Yu * 3) res:/ 765e79f15a4SChen Yu * mon:mon0 766e79f15a4SChen Yu * 767e79f15a4SChen Yu * Task is part of the root resctrl control group and monitor group mon0. 768e79f15a4SChen Yu * 769e79f15a4SChen Yu * 4) res:group0 770e79f15a4SChen Yu * mon: 771e79f15a4SChen Yu * 772e79f15a4SChen Yu * Task is part of resctrl control group group0, and it is not associated 773e79f15a4SChen Yu * to any monitor group. 774e79f15a4SChen Yu * 775e79f15a4SChen Yu * 5) res:group0 776e79f15a4SChen Yu * mon:mon1 777e79f15a4SChen Yu * 778e79f15a4SChen Yu * Task is part of resctrl control group group0 and monitor group mon1. 779e79f15a4SChen Yu */ 780e79f15a4SChen Yu int proc_resctrl_show(struct seq_file *s, struct pid_namespace *ns, 781e79f15a4SChen Yu struct pid *pid, struct task_struct *tsk) 782e79f15a4SChen Yu { 783e79f15a4SChen Yu struct rdtgroup *rdtg; 784e79f15a4SChen Yu int ret = 0; 785e79f15a4SChen Yu 786e79f15a4SChen Yu mutex_lock(&rdtgroup_mutex); 787e79f15a4SChen Yu 788e79f15a4SChen Yu /* Return empty if resctrl has not been mounted. */ 789e79f15a4SChen Yu if (!static_branch_unlikely(&rdt_enable_key)) { 790e79f15a4SChen Yu seq_puts(s, "res:\nmon:\n"); 791e79f15a4SChen Yu goto unlock; 792e79f15a4SChen Yu } 793e79f15a4SChen Yu 794e79f15a4SChen Yu list_for_each_entry(rdtg, &rdt_all_groups, rdtgroup_list) { 795e79f15a4SChen Yu struct rdtgroup *crg; 796e79f15a4SChen Yu 797e79f15a4SChen Yu /* 798e79f15a4SChen Yu * Task information is only relevant for shareable 799e79f15a4SChen Yu * and exclusive groups. 800e79f15a4SChen Yu */ 801e79f15a4SChen Yu if (rdtg->mode != RDT_MODE_SHAREABLE && 802e79f15a4SChen Yu rdtg->mode != RDT_MODE_EXCLUSIVE) 803e79f15a4SChen Yu continue; 804e79f15a4SChen Yu 805e79f15a4SChen Yu if (rdtg->closid != tsk->closid) 806e79f15a4SChen Yu continue; 807e79f15a4SChen Yu 808e79f15a4SChen Yu seq_printf(s, "res:%s%s\n", (rdtg == &rdtgroup_default) ? "/" : "", 809e79f15a4SChen Yu rdtg->kn->name); 810e79f15a4SChen Yu seq_puts(s, "mon:"); 811e79f15a4SChen Yu list_for_each_entry(crg, &rdtg->mon.crdtgrp_list, 812e79f15a4SChen Yu mon.crdtgrp_list) { 813e79f15a4SChen Yu if (tsk->rmid != crg->mon.rmid) 814e79f15a4SChen Yu continue; 815e79f15a4SChen Yu seq_printf(s, "%s", crg->kn->name); 816e79f15a4SChen Yu break; 817e79f15a4SChen Yu } 818e79f15a4SChen Yu seq_putc(s, '\n'); 819e79f15a4SChen Yu goto unlock; 820e79f15a4SChen Yu } 821e79f15a4SChen Yu /* 822e79f15a4SChen Yu * The above search should succeed. Otherwise return 823e79f15a4SChen Yu * with an error. 824e79f15a4SChen Yu */ 825e79f15a4SChen Yu ret = -ENOENT; 826e79f15a4SChen Yu unlock: 827e79f15a4SChen Yu mutex_unlock(&rdtgroup_mutex); 828e79f15a4SChen Yu 829e79f15a4SChen Yu return ret; 830e79f15a4SChen Yu } 831e79f15a4SChen Yu #endif 832e79f15a4SChen Yu 833fa7d9493SBabu Moger static int rdt_last_cmd_status_show(struct kernfs_open_file *of, 834fa7d9493SBabu Moger struct seq_file *seq, void *v) 835fa7d9493SBabu Moger { 836fa7d9493SBabu Moger int len; 837fa7d9493SBabu Moger 838fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 839fa7d9493SBabu Moger len = seq_buf_used(&last_cmd_status); 840fa7d9493SBabu Moger if (len) 841fa7d9493SBabu Moger seq_printf(seq, "%.*s", len, last_cmd_status_buf); 842fa7d9493SBabu Moger else 843fa7d9493SBabu Moger seq_puts(seq, "ok\n"); 844fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 845fa7d9493SBabu Moger return 0; 846fa7d9493SBabu Moger } 847fa7d9493SBabu Moger 848fa7d9493SBabu Moger static int rdt_num_closids_show(struct kernfs_open_file *of, 849fa7d9493SBabu Moger struct seq_file *seq, void *v) 850fa7d9493SBabu Moger { 851fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 85263c8b123SJames Morse struct rdt_hw_resource *hw_res; 853fa7d9493SBabu Moger 85463c8b123SJames Morse hw_res = resctrl_to_arch_res(r); 85563c8b123SJames Morse seq_printf(seq, "%d\n", hw_res->num_closid); 856fa7d9493SBabu Moger return 0; 857fa7d9493SBabu Moger } 858fa7d9493SBabu Moger 859fa7d9493SBabu Moger static int rdt_default_ctrl_show(struct kernfs_open_file *of, 860fa7d9493SBabu Moger struct seq_file *seq, void *v) 861fa7d9493SBabu Moger { 862fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 863fa7d9493SBabu Moger 864fa7d9493SBabu Moger seq_printf(seq, "%x\n", r->default_ctrl); 865fa7d9493SBabu Moger return 0; 866fa7d9493SBabu Moger } 867fa7d9493SBabu Moger 868fa7d9493SBabu Moger static int rdt_min_cbm_bits_show(struct kernfs_open_file *of, 869fa7d9493SBabu Moger struct seq_file *seq, void *v) 870fa7d9493SBabu Moger { 871fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 872fa7d9493SBabu Moger 873fa7d9493SBabu Moger seq_printf(seq, "%u\n", r->cache.min_cbm_bits); 874fa7d9493SBabu Moger return 0; 875fa7d9493SBabu Moger } 876fa7d9493SBabu Moger 877fa7d9493SBabu Moger static int rdt_shareable_bits_show(struct kernfs_open_file *of, 878fa7d9493SBabu Moger struct seq_file *seq, void *v) 879fa7d9493SBabu Moger { 880fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 881fa7d9493SBabu Moger 882fa7d9493SBabu Moger seq_printf(seq, "%x\n", r->cache.shareable_bits); 883fa7d9493SBabu Moger return 0; 884fa7d9493SBabu Moger } 885fa7d9493SBabu Moger 886fa7d9493SBabu Moger /** 887fa7d9493SBabu Moger * rdt_bit_usage_show - Display current usage of resources 888fa7d9493SBabu Moger * 889fa7d9493SBabu Moger * A domain is a shared resource that can now be allocated differently. Here 890fa7d9493SBabu Moger * we display the current regions of the domain as an annotated bitmask. 891fa7d9493SBabu Moger * For each domain of this resource its allocation bitmask 892fa7d9493SBabu Moger * is annotated as below to indicate the current usage of the corresponding bit: 893fa7d9493SBabu Moger * 0 - currently unused 894fa7d9493SBabu Moger * X - currently available for sharing and used by software and hardware 895fa7d9493SBabu Moger * H - currently used by hardware only but available for software use 896fa7d9493SBabu Moger * S - currently used and shareable by software only 897fa7d9493SBabu Moger * E - currently used exclusively by one resource group 898fa7d9493SBabu Moger * P - currently pseudo-locked by one resource group 899fa7d9493SBabu Moger */ 900fa7d9493SBabu Moger static int rdt_bit_usage_show(struct kernfs_open_file *of, 901fa7d9493SBabu Moger struct seq_file *seq, void *v) 902fa7d9493SBabu Moger { 903fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 90432f010deSReinette Chatre /* 90532f010deSReinette Chatre * Use unsigned long even though only 32 bits are used to ensure 90632f010deSReinette Chatre * test_bit() is used safely. 90732f010deSReinette Chatre */ 90832f010deSReinette Chatre unsigned long sw_shareable = 0, hw_shareable = 0; 90932f010deSReinette Chatre unsigned long exclusive = 0, pseudo_locked = 0; 910fa7d9493SBabu Moger struct rdt_domain *dom; 911fa7d9493SBabu Moger int i, hwb, swb, excl, psl; 912fa7d9493SBabu Moger enum rdtgrp_mode mode; 913fa7d9493SBabu Moger bool sep = false; 914fa7d9493SBabu Moger u32 *ctrl; 915fa7d9493SBabu Moger 916fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 917fa7d9493SBabu Moger hw_shareable = r->cache.shareable_bits; 918fa7d9493SBabu Moger list_for_each_entry(dom, &r->domains, list) { 919fa7d9493SBabu Moger if (sep) 920fa7d9493SBabu Moger seq_putc(seq, ';'); 921792e0f6fSJames Morse ctrl = resctrl_to_arch_dom(dom)->ctrl_val; 922fa7d9493SBabu Moger sw_shareable = 0; 923fa7d9493SBabu Moger exclusive = 0; 924fa7d9493SBabu Moger seq_printf(seq, "%d=", dom->id); 925fa7d9493SBabu Moger for (i = 0; i < closids_supported(); i++, ctrl++) { 926fa7d9493SBabu Moger if (!closid_allocated(i)) 927fa7d9493SBabu Moger continue; 928fa7d9493SBabu Moger mode = rdtgroup_mode_by_closid(i); 929fa7d9493SBabu Moger switch (mode) { 930fa7d9493SBabu Moger case RDT_MODE_SHAREABLE: 931fa7d9493SBabu Moger sw_shareable |= *ctrl; 932fa7d9493SBabu Moger break; 933fa7d9493SBabu Moger case RDT_MODE_EXCLUSIVE: 934fa7d9493SBabu Moger exclusive |= *ctrl; 935fa7d9493SBabu Moger break; 936fa7d9493SBabu Moger case RDT_MODE_PSEUDO_LOCKSETUP: 937fa7d9493SBabu Moger /* 938fa7d9493SBabu Moger * RDT_MODE_PSEUDO_LOCKSETUP is possible 939fa7d9493SBabu Moger * here but not included since the CBM 940fa7d9493SBabu Moger * associated with this CLOSID in this mode 941fa7d9493SBabu Moger * is not initialized and no task or cpu can be 942fa7d9493SBabu Moger * assigned this CLOSID. 943fa7d9493SBabu Moger */ 944fa7d9493SBabu Moger break; 945fa7d9493SBabu Moger case RDT_MODE_PSEUDO_LOCKED: 946fa7d9493SBabu Moger case RDT_NUM_MODES: 947fa7d9493SBabu Moger WARN(1, 948fa7d9493SBabu Moger "invalid mode for closid %d\n", i); 949fa7d9493SBabu Moger break; 950fa7d9493SBabu Moger } 951fa7d9493SBabu Moger } 952fa7d9493SBabu Moger for (i = r->cache.cbm_len - 1; i >= 0; i--) { 953fa7d9493SBabu Moger pseudo_locked = dom->plr ? dom->plr->cbm : 0; 95432f010deSReinette Chatre hwb = test_bit(i, &hw_shareable); 95532f010deSReinette Chatre swb = test_bit(i, &sw_shareable); 95632f010deSReinette Chatre excl = test_bit(i, &exclusive); 95732f010deSReinette Chatre psl = test_bit(i, &pseudo_locked); 958fa7d9493SBabu Moger if (hwb && swb) 959fa7d9493SBabu Moger seq_putc(seq, 'X'); 960fa7d9493SBabu Moger else if (hwb && !swb) 961fa7d9493SBabu Moger seq_putc(seq, 'H'); 962fa7d9493SBabu Moger else if (!hwb && swb) 963fa7d9493SBabu Moger seq_putc(seq, 'S'); 964fa7d9493SBabu Moger else if (excl) 965fa7d9493SBabu Moger seq_putc(seq, 'E'); 966fa7d9493SBabu Moger else if (psl) 967fa7d9493SBabu Moger seq_putc(seq, 'P'); 968fa7d9493SBabu Moger else /* Unused bits remain */ 969fa7d9493SBabu Moger seq_putc(seq, '0'); 970fa7d9493SBabu Moger } 971fa7d9493SBabu Moger sep = true; 972fa7d9493SBabu Moger } 973fa7d9493SBabu Moger seq_putc(seq, '\n'); 974fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 975fa7d9493SBabu Moger return 0; 976fa7d9493SBabu Moger } 977fa7d9493SBabu Moger 978fa7d9493SBabu Moger static int rdt_min_bw_show(struct kernfs_open_file *of, 979fa7d9493SBabu Moger struct seq_file *seq, void *v) 980fa7d9493SBabu Moger { 981fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 982fa7d9493SBabu Moger 983fa7d9493SBabu Moger seq_printf(seq, "%u\n", r->membw.min_bw); 984fa7d9493SBabu Moger return 0; 985fa7d9493SBabu Moger } 986fa7d9493SBabu Moger 987fa7d9493SBabu Moger static int rdt_num_rmids_show(struct kernfs_open_file *of, 988fa7d9493SBabu Moger struct seq_file *seq, void *v) 989fa7d9493SBabu Moger { 990fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 991fa7d9493SBabu Moger 992fa7d9493SBabu Moger seq_printf(seq, "%d\n", r->num_rmid); 993fa7d9493SBabu Moger 994fa7d9493SBabu Moger return 0; 995fa7d9493SBabu Moger } 996fa7d9493SBabu Moger 997fa7d9493SBabu Moger static int rdt_mon_features_show(struct kernfs_open_file *of, 998fa7d9493SBabu Moger struct seq_file *seq, void *v) 999fa7d9493SBabu Moger { 1000fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 1001fa7d9493SBabu Moger struct mon_evt *mevt; 1002fa7d9493SBabu Moger 1003fa7d9493SBabu Moger list_for_each_entry(mevt, &r->evt_list, list) 1004fa7d9493SBabu Moger seq_printf(seq, "%s\n", mevt->name); 1005fa7d9493SBabu Moger 1006fa7d9493SBabu Moger return 0; 1007fa7d9493SBabu Moger } 1008fa7d9493SBabu Moger 1009fa7d9493SBabu Moger static int rdt_bw_gran_show(struct kernfs_open_file *of, 1010fa7d9493SBabu Moger struct seq_file *seq, void *v) 1011fa7d9493SBabu Moger { 1012fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 1013fa7d9493SBabu Moger 1014fa7d9493SBabu Moger seq_printf(seq, "%u\n", r->membw.bw_gran); 1015fa7d9493SBabu Moger return 0; 1016fa7d9493SBabu Moger } 1017fa7d9493SBabu Moger 1018fa7d9493SBabu Moger static int rdt_delay_linear_show(struct kernfs_open_file *of, 1019fa7d9493SBabu Moger struct seq_file *seq, void *v) 1020fa7d9493SBabu Moger { 1021fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 1022fa7d9493SBabu Moger 1023fa7d9493SBabu Moger seq_printf(seq, "%u\n", r->membw.delay_linear); 1024fa7d9493SBabu Moger return 0; 1025fa7d9493SBabu Moger } 1026fa7d9493SBabu Moger 1027fa7d9493SBabu Moger static int max_threshold_occ_show(struct kernfs_open_file *of, 1028fa7d9493SBabu Moger struct seq_file *seq, void *v) 1029fa7d9493SBabu Moger { 1030fa7d9493SBabu Moger struct rdt_resource *r = of->kn->parent->priv; 103163c8b123SJames Morse struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 1032fa7d9493SBabu Moger 103363c8b123SJames Morse seq_printf(seq, "%u\n", resctrl_cqm_threshold * hw_res->mon_scale); 1034fa7d9493SBabu Moger 1035fa7d9493SBabu Moger return 0; 1036fa7d9493SBabu Moger } 1037fa7d9493SBabu Moger 103829b6bd41SFenghua Yu static int rdt_thread_throttle_mode_show(struct kernfs_open_file *of, 103929b6bd41SFenghua Yu struct seq_file *seq, void *v) 104029b6bd41SFenghua Yu { 104129b6bd41SFenghua Yu struct rdt_resource *r = of->kn->parent->priv; 104229b6bd41SFenghua Yu 104329b6bd41SFenghua Yu if (r->membw.throttle_mode == THREAD_THROTTLE_PER_THREAD) 104429b6bd41SFenghua Yu seq_puts(seq, "per-thread\n"); 104529b6bd41SFenghua Yu else 104629b6bd41SFenghua Yu seq_puts(seq, "max\n"); 104729b6bd41SFenghua Yu 104829b6bd41SFenghua Yu return 0; 104929b6bd41SFenghua Yu } 105029b6bd41SFenghua Yu 1051fa7d9493SBabu Moger static ssize_t max_threshold_occ_write(struct kernfs_open_file *of, 1052fa7d9493SBabu Moger char *buf, size_t nbytes, loff_t off) 1053fa7d9493SBabu Moger { 105463c8b123SJames Morse struct rdt_hw_resource *hw_res; 1055fa7d9493SBabu Moger unsigned int bytes; 1056fa7d9493SBabu Moger int ret; 1057fa7d9493SBabu Moger 1058fa7d9493SBabu Moger ret = kstrtouint(buf, 0, &bytes); 1059fa7d9493SBabu Moger if (ret) 1060fa7d9493SBabu Moger return ret; 1061fa7d9493SBabu Moger 1062fa7d9493SBabu Moger if (bytes > (boot_cpu_data.x86_cache_size * 1024)) 1063fa7d9493SBabu Moger return -EINVAL; 1064fa7d9493SBabu Moger 106563c8b123SJames Morse hw_res = resctrl_to_arch_res(of->kn->parent->priv); 106663c8b123SJames Morse resctrl_cqm_threshold = bytes / hw_res->mon_scale; 1067fa7d9493SBabu Moger 1068fa7d9493SBabu Moger return nbytes; 1069fa7d9493SBabu Moger } 1070fa7d9493SBabu Moger 1071fa7d9493SBabu Moger /* 1072fa7d9493SBabu Moger * rdtgroup_mode_show - Display mode of this resource group 1073fa7d9493SBabu Moger */ 1074fa7d9493SBabu Moger static int rdtgroup_mode_show(struct kernfs_open_file *of, 1075fa7d9493SBabu Moger struct seq_file *s, void *v) 1076fa7d9493SBabu Moger { 1077fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 1078fa7d9493SBabu Moger 1079fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 1080fa7d9493SBabu Moger if (!rdtgrp) { 1081fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1082fa7d9493SBabu Moger return -ENOENT; 1083fa7d9493SBabu Moger } 1084fa7d9493SBabu Moger 1085fa7d9493SBabu Moger seq_printf(s, "%s\n", rdtgroup_mode_str(rdtgrp->mode)); 1086fa7d9493SBabu Moger 1087fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1088fa7d9493SBabu Moger return 0; 1089fa7d9493SBabu Moger } 1090fa7d9493SBabu Moger 1091fa7d9493SBabu Moger /** 1092fa7d9493SBabu Moger * rdt_cdp_peer_get - Retrieve CDP peer if it exists 1093fa7d9493SBabu Moger * @r: RDT resource to which RDT domain @d belongs 1094fa7d9493SBabu Moger * @d: Cache instance for which a CDP peer is requested 1095fa7d9493SBabu Moger * @r_cdp: RDT resource that shares hardware with @r (RDT resource peer) 1096fa7d9493SBabu Moger * Used to return the result. 1097fa7d9493SBabu Moger * @d_cdp: RDT domain that shares hardware with @d (RDT domain peer) 1098fa7d9493SBabu Moger * Used to return the result. 1099fa7d9493SBabu Moger * 1100fa7d9493SBabu Moger * RDT resources are managed independently and by extension the RDT domains 1101fa7d9493SBabu Moger * (RDT resource instances) are managed independently also. The Code and 1102fa7d9493SBabu Moger * Data Prioritization (CDP) RDT resources, while managed independently, 1103fa7d9493SBabu Moger * could refer to the same underlying hardware. For example, 1104fa7d9493SBabu Moger * RDT_RESOURCE_L2CODE and RDT_RESOURCE_L2DATA both refer to the L2 cache. 1105fa7d9493SBabu Moger * 1106fa7d9493SBabu Moger * When provided with an RDT resource @r and an instance of that RDT 1107fa7d9493SBabu Moger * resource @d rdt_cdp_peer_get() will return if there is a peer RDT 1108fa7d9493SBabu Moger * resource and the exact instance that shares the same hardware. 1109fa7d9493SBabu Moger * 1110fa7d9493SBabu Moger * Return: 0 if a CDP peer was found, <0 on error or if no CDP peer exists. 1111fa7d9493SBabu Moger * If a CDP peer was found, @r_cdp will point to the peer RDT resource 1112fa7d9493SBabu Moger * and @d_cdp will point to the peer RDT domain. 1113fa7d9493SBabu Moger */ 1114fa7d9493SBabu Moger static int rdt_cdp_peer_get(struct rdt_resource *r, struct rdt_domain *d, 1115fa7d9493SBabu Moger struct rdt_resource **r_cdp, 1116fa7d9493SBabu Moger struct rdt_domain **d_cdp) 1117fa7d9493SBabu Moger { 1118fa7d9493SBabu Moger struct rdt_resource *_r_cdp = NULL; 1119fa7d9493SBabu Moger struct rdt_domain *_d_cdp = NULL; 1120fa7d9493SBabu Moger int ret = 0; 1121fa7d9493SBabu Moger 1122fa7d9493SBabu Moger switch (r->rid) { 1123fa7d9493SBabu Moger case RDT_RESOURCE_L3DATA: 112463c8b123SJames Morse _r_cdp = &rdt_resources_all[RDT_RESOURCE_L3CODE].r_resctrl; 1125fa7d9493SBabu Moger break; 1126fa7d9493SBabu Moger case RDT_RESOURCE_L3CODE: 112763c8b123SJames Morse _r_cdp = &rdt_resources_all[RDT_RESOURCE_L3DATA].r_resctrl; 1128fa7d9493SBabu Moger break; 1129fa7d9493SBabu Moger case RDT_RESOURCE_L2DATA: 113063c8b123SJames Morse _r_cdp = &rdt_resources_all[RDT_RESOURCE_L2CODE].r_resctrl; 1131fa7d9493SBabu Moger break; 1132fa7d9493SBabu Moger case RDT_RESOURCE_L2CODE: 113363c8b123SJames Morse _r_cdp = &rdt_resources_all[RDT_RESOURCE_L2DATA].r_resctrl; 1134fa7d9493SBabu Moger break; 1135fa7d9493SBabu Moger default: 1136fa7d9493SBabu Moger ret = -ENOENT; 1137fa7d9493SBabu Moger goto out; 1138fa7d9493SBabu Moger } 1139fa7d9493SBabu Moger 1140fa7d9493SBabu Moger /* 1141fa7d9493SBabu Moger * When a new CPU comes online and CDP is enabled then the new 1142fa7d9493SBabu Moger * RDT domains (if any) associated with both CDP RDT resources 1143fa7d9493SBabu Moger * are added in the same CPU online routine while the 1144fa7d9493SBabu Moger * rdtgroup_mutex is held. It should thus not happen for one 1145fa7d9493SBabu Moger * RDT domain to exist and be associated with its RDT CDP 1146fa7d9493SBabu Moger * resource but there is no RDT domain associated with the 1147fa7d9493SBabu Moger * peer RDT CDP resource. Hence the WARN. 1148fa7d9493SBabu Moger */ 1149fa7d9493SBabu Moger _d_cdp = rdt_find_domain(_r_cdp, d->id, NULL); 115052eb7433SReinette Chatre if (WARN_ON(IS_ERR_OR_NULL(_d_cdp))) { 1151fa7d9493SBabu Moger _r_cdp = NULL; 1152cc5277feSDan Carpenter _d_cdp = NULL; 1153fa7d9493SBabu Moger ret = -EINVAL; 1154fa7d9493SBabu Moger } 1155fa7d9493SBabu Moger 1156fa7d9493SBabu Moger out: 1157fa7d9493SBabu Moger *r_cdp = _r_cdp; 1158fa7d9493SBabu Moger *d_cdp = _d_cdp; 1159fa7d9493SBabu Moger 1160fa7d9493SBabu Moger return ret; 1161fa7d9493SBabu Moger } 1162fa7d9493SBabu Moger 1163fa7d9493SBabu Moger /** 1164fa7d9493SBabu Moger * __rdtgroup_cbm_overlaps - Does CBM for intended closid overlap with other 1165fa7d9493SBabu Moger * @r: Resource to which domain instance @d belongs. 1166fa7d9493SBabu Moger * @d: The domain instance for which @closid is being tested. 1167fa7d9493SBabu Moger * @cbm: Capacity bitmask being tested. 1168fa7d9493SBabu Moger * @closid: Intended closid for @cbm. 1169fa7d9493SBabu Moger * @exclusive: Only check if overlaps with exclusive resource groups 1170fa7d9493SBabu Moger * 1171fa7d9493SBabu Moger * Checks if provided @cbm intended to be used for @closid on domain 1172fa7d9493SBabu Moger * @d overlaps with any other closids or other hardware usage associated 1173fa7d9493SBabu Moger * with this domain. If @exclusive is true then only overlaps with 1174fa7d9493SBabu Moger * resource groups in exclusive mode will be considered. If @exclusive 1175fa7d9493SBabu Moger * is false then overlaps with any resource group or hardware entities 1176fa7d9493SBabu Moger * will be considered. 1177fa7d9493SBabu Moger * 1178fa7d9493SBabu Moger * @cbm is unsigned long, even if only 32 bits are used, to make the 1179fa7d9493SBabu Moger * bitmap functions work correctly. 1180fa7d9493SBabu Moger * 1181fa7d9493SBabu Moger * Return: false if CBM does not overlap, true if it does. 1182fa7d9493SBabu Moger */ 1183fa7d9493SBabu Moger static bool __rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d, 1184fa7d9493SBabu Moger unsigned long cbm, int closid, bool exclusive) 1185fa7d9493SBabu Moger { 1186fa7d9493SBabu Moger enum rdtgrp_mode mode; 1187fa7d9493SBabu Moger unsigned long ctrl_b; 1188fa7d9493SBabu Moger u32 *ctrl; 1189fa7d9493SBabu Moger int i; 1190fa7d9493SBabu Moger 1191fa7d9493SBabu Moger /* Check for any overlap with regions used by hardware directly */ 1192fa7d9493SBabu Moger if (!exclusive) { 1193fa7d9493SBabu Moger ctrl_b = r->cache.shareable_bits; 1194fa7d9493SBabu Moger if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) 1195fa7d9493SBabu Moger return true; 1196fa7d9493SBabu Moger } 1197fa7d9493SBabu Moger 1198fa7d9493SBabu Moger /* Check for overlap with other resource groups */ 1199792e0f6fSJames Morse ctrl = resctrl_to_arch_dom(d)->ctrl_val; 1200fa7d9493SBabu Moger for (i = 0; i < closids_supported(); i++, ctrl++) { 1201fa7d9493SBabu Moger ctrl_b = *ctrl; 1202fa7d9493SBabu Moger mode = rdtgroup_mode_by_closid(i); 1203fa7d9493SBabu Moger if (closid_allocated(i) && i != closid && 1204fa7d9493SBabu Moger mode != RDT_MODE_PSEUDO_LOCKSETUP) { 1205fa7d9493SBabu Moger if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) { 1206fa7d9493SBabu Moger if (exclusive) { 1207fa7d9493SBabu Moger if (mode == RDT_MODE_EXCLUSIVE) 1208fa7d9493SBabu Moger return true; 1209fa7d9493SBabu Moger continue; 1210fa7d9493SBabu Moger } 1211fa7d9493SBabu Moger return true; 1212fa7d9493SBabu Moger } 1213fa7d9493SBabu Moger } 1214fa7d9493SBabu Moger } 1215fa7d9493SBabu Moger 1216fa7d9493SBabu Moger return false; 1217fa7d9493SBabu Moger } 1218fa7d9493SBabu Moger 1219fa7d9493SBabu Moger /** 1220fa7d9493SBabu Moger * rdtgroup_cbm_overlaps - Does CBM overlap with other use of hardware 1221fa7d9493SBabu Moger * @r: Resource to which domain instance @d belongs. 1222fa7d9493SBabu Moger * @d: The domain instance for which @closid is being tested. 1223fa7d9493SBabu Moger * @cbm: Capacity bitmask being tested. 1224fa7d9493SBabu Moger * @closid: Intended closid for @cbm. 1225fa7d9493SBabu Moger * @exclusive: Only check if overlaps with exclusive resource groups 1226fa7d9493SBabu Moger * 1227fa7d9493SBabu Moger * Resources that can be allocated using a CBM can use the CBM to control 1228fa7d9493SBabu Moger * the overlap of these allocations. rdtgroup_cmb_overlaps() is the test 1229fa7d9493SBabu Moger * for overlap. Overlap test is not limited to the specific resource for 1230fa7d9493SBabu Moger * which the CBM is intended though - when dealing with CDP resources that 1231fa7d9493SBabu Moger * share the underlying hardware the overlap check should be performed on 1232fa7d9493SBabu Moger * the CDP resource sharing the hardware also. 1233fa7d9493SBabu Moger * 1234fa7d9493SBabu Moger * Refer to description of __rdtgroup_cbm_overlaps() for the details of the 1235fa7d9493SBabu Moger * overlap test. 1236fa7d9493SBabu Moger * 1237fa7d9493SBabu Moger * Return: true if CBM overlap detected, false if there is no overlap 1238fa7d9493SBabu Moger */ 1239fa7d9493SBabu Moger bool rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d, 1240fa7d9493SBabu Moger unsigned long cbm, int closid, bool exclusive) 1241fa7d9493SBabu Moger { 1242fa7d9493SBabu Moger struct rdt_resource *r_cdp; 1243fa7d9493SBabu Moger struct rdt_domain *d_cdp; 1244fa7d9493SBabu Moger 1245fa7d9493SBabu Moger if (__rdtgroup_cbm_overlaps(r, d, cbm, closid, exclusive)) 1246fa7d9493SBabu Moger return true; 1247fa7d9493SBabu Moger 1248fa7d9493SBabu Moger if (rdt_cdp_peer_get(r, d, &r_cdp, &d_cdp) < 0) 1249fa7d9493SBabu Moger return false; 1250fa7d9493SBabu Moger 1251fa7d9493SBabu Moger return __rdtgroup_cbm_overlaps(r_cdp, d_cdp, cbm, closid, exclusive); 1252fa7d9493SBabu Moger } 1253fa7d9493SBabu Moger 1254fa7d9493SBabu Moger /** 1255fa7d9493SBabu Moger * rdtgroup_mode_test_exclusive - Test if this resource group can be exclusive 1256fa7d9493SBabu Moger * 1257fa7d9493SBabu Moger * An exclusive resource group implies that there should be no sharing of 1258fa7d9493SBabu Moger * its allocated resources. At the time this group is considered to be 1259fa7d9493SBabu Moger * exclusive this test can determine if its current schemata supports this 1260fa7d9493SBabu Moger * setting by testing for overlap with all other resource groups. 1261fa7d9493SBabu Moger * 1262fa7d9493SBabu Moger * Return: true if resource group can be exclusive, false if there is overlap 1263fa7d9493SBabu Moger * with allocations of other resource groups and thus this resource group 1264fa7d9493SBabu Moger * cannot be exclusive. 1265fa7d9493SBabu Moger */ 1266fa7d9493SBabu Moger static bool rdtgroup_mode_test_exclusive(struct rdtgroup *rdtgrp) 1267fa7d9493SBabu Moger { 1268792e0f6fSJames Morse struct rdt_hw_domain *hw_dom; 1269fa7d9493SBabu Moger int closid = rdtgrp->closid; 1270fa7d9493SBabu Moger struct rdt_resource *r; 1271fa7d9493SBabu Moger bool has_cache = false; 1272fa7d9493SBabu Moger struct rdt_domain *d; 1273fa7d9493SBabu Moger 1274fa7d9493SBabu Moger for_each_alloc_enabled_rdt_resource(r) { 1275fa7d9493SBabu Moger if (r->rid == RDT_RESOURCE_MBA) 1276fa7d9493SBabu Moger continue; 1277fa7d9493SBabu Moger has_cache = true; 1278fa7d9493SBabu Moger list_for_each_entry(d, &r->domains, list) { 1279792e0f6fSJames Morse hw_dom = resctrl_to_arch_dom(d); 1280792e0f6fSJames Morse if (rdtgroup_cbm_overlaps(r, d, hw_dom->ctrl_val[closid], 1281fa7d9493SBabu Moger rdtgrp->closid, false)) { 1282723f1a0dSBabu Moger rdt_last_cmd_puts("Schemata overlaps\n"); 1283fa7d9493SBabu Moger return false; 1284fa7d9493SBabu Moger } 1285fa7d9493SBabu Moger } 1286fa7d9493SBabu Moger } 1287fa7d9493SBabu Moger 1288fa7d9493SBabu Moger if (!has_cache) { 1289723f1a0dSBabu Moger rdt_last_cmd_puts("Cannot be exclusive without CAT/CDP\n"); 1290fa7d9493SBabu Moger return false; 1291fa7d9493SBabu Moger } 1292fa7d9493SBabu Moger 1293fa7d9493SBabu Moger return true; 1294fa7d9493SBabu Moger } 1295fa7d9493SBabu Moger 1296fa7d9493SBabu Moger /** 1297fa7d9493SBabu Moger * rdtgroup_mode_write - Modify the resource group's mode 1298fa7d9493SBabu Moger * 1299fa7d9493SBabu Moger */ 1300fa7d9493SBabu Moger static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, 1301fa7d9493SBabu Moger char *buf, size_t nbytes, loff_t off) 1302fa7d9493SBabu Moger { 1303fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 1304fa7d9493SBabu Moger enum rdtgrp_mode mode; 1305fa7d9493SBabu Moger int ret = 0; 1306fa7d9493SBabu Moger 1307fa7d9493SBabu Moger /* Valid input requires a trailing newline */ 1308fa7d9493SBabu Moger if (nbytes == 0 || buf[nbytes - 1] != '\n') 1309fa7d9493SBabu Moger return -EINVAL; 1310fa7d9493SBabu Moger buf[nbytes - 1] = '\0'; 1311fa7d9493SBabu Moger 1312fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 1313fa7d9493SBabu Moger if (!rdtgrp) { 1314fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1315fa7d9493SBabu Moger return -ENOENT; 1316fa7d9493SBabu Moger } 1317fa7d9493SBabu Moger 1318fa7d9493SBabu Moger rdt_last_cmd_clear(); 1319fa7d9493SBabu Moger 1320fa7d9493SBabu Moger mode = rdtgrp->mode; 1321fa7d9493SBabu Moger 1322fa7d9493SBabu Moger if ((!strcmp(buf, "shareable") && mode == RDT_MODE_SHAREABLE) || 1323fa7d9493SBabu Moger (!strcmp(buf, "exclusive") && mode == RDT_MODE_EXCLUSIVE) || 1324fa7d9493SBabu Moger (!strcmp(buf, "pseudo-locksetup") && 1325fa7d9493SBabu Moger mode == RDT_MODE_PSEUDO_LOCKSETUP) || 1326fa7d9493SBabu Moger (!strcmp(buf, "pseudo-locked") && mode == RDT_MODE_PSEUDO_LOCKED)) 1327fa7d9493SBabu Moger goto out; 1328fa7d9493SBabu Moger 1329fa7d9493SBabu Moger if (mode == RDT_MODE_PSEUDO_LOCKED) { 133045682489SReinette Chatre rdt_last_cmd_puts("Cannot change pseudo-locked group\n"); 1331fa7d9493SBabu Moger ret = -EINVAL; 1332fa7d9493SBabu Moger goto out; 1333fa7d9493SBabu Moger } 1334fa7d9493SBabu Moger 1335fa7d9493SBabu Moger if (!strcmp(buf, "shareable")) { 1336fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1337fa7d9493SBabu Moger ret = rdtgroup_locksetup_exit(rdtgrp); 1338fa7d9493SBabu Moger if (ret) 1339fa7d9493SBabu Moger goto out; 1340fa7d9493SBabu Moger } 1341fa7d9493SBabu Moger rdtgrp->mode = RDT_MODE_SHAREABLE; 1342fa7d9493SBabu Moger } else if (!strcmp(buf, "exclusive")) { 1343fa7d9493SBabu Moger if (!rdtgroup_mode_test_exclusive(rdtgrp)) { 1344fa7d9493SBabu Moger ret = -EINVAL; 1345fa7d9493SBabu Moger goto out; 1346fa7d9493SBabu Moger } 1347fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1348fa7d9493SBabu Moger ret = rdtgroup_locksetup_exit(rdtgrp); 1349fa7d9493SBabu Moger if (ret) 1350fa7d9493SBabu Moger goto out; 1351fa7d9493SBabu Moger } 1352fa7d9493SBabu Moger rdtgrp->mode = RDT_MODE_EXCLUSIVE; 1353fa7d9493SBabu Moger } else if (!strcmp(buf, "pseudo-locksetup")) { 1354fa7d9493SBabu Moger ret = rdtgroup_locksetup_enter(rdtgrp); 1355fa7d9493SBabu Moger if (ret) 1356fa7d9493SBabu Moger goto out; 1357fa7d9493SBabu Moger rdtgrp->mode = RDT_MODE_PSEUDO_LOCKSETUP; 1358fa7d9493SBabu Moger } else { 135945682489SReinette Chatre rdt_last_cmd_puts("Unknown or unsupported mode\n"); 1360fa7d9493SBabu Moger ret = -EINVAL; 1361fa7d9493SBabu Moger } 1362fa7d9493SBabu Moger 1363fa7d9493SBabu Moger out: 1364fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1365fa7d9493SBabu Moger return ret ?: nbytes; 1366fa7d9493SBabu Moger } 1367fa7d9493SBabu Moger 1368fa7d9493SBabu Moger /** 1369fa7d9493SBabu Moger * rdtgroup_cbm_to_size - Translate CBM to size in bytes 1370fa7d9493SBabu Moger * @r: RDT resource to which @d belongs. 1371fa7d9493SBabu Moger * @d: RDT domain instance. 1372fa7d9493SBabu Moger * @cbm: bitmask for which the size should be computed. 1373fa7d9493SBabu Moger * 1374fa7d9493SBabu Moger * The bitmask provided associated with the RDT domain instance @d will be 1375fa7d9493SBabu Moger * translated into how many bytes it represents. The size in bytes is 1376fa7d9493SBabu Moger * computed by first dividing the total cache size by the CBM length to 1377fa7d9493SBabu Moger * determine how many bytes each bit in the bitmask represents. The result 1378fa7d9493SBabu Moger * is multiplied with the number of bits set in the bitmask. 1379fa7d9493SBabu Moger * 1380fa7d9493SBabu Moger * @cbm is unsigned long, even if only 32 bits are used to make the 1381fa7d9493SBabu Moger * bitmap functions work correctly. 1382fa7d9493SBabu Moger */ 1383fa7d9493SBabu Moger unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, 1384fa7d9493SBabu Moger struct rdt_domain *d, unsigned long cbm) 1385fa7d9493SBabu Moger { 1386fa7d9493SBabu Moger struct cpu_cacheinfo *ci; 1387fa7d9493SBabu Moger unsigned int size = 0; 1388fa7d9493SBabu Moger int num_b, i; 1389fa7d9493SBabu Moger 1390fa7d9493SBabu Moger num_b = bitmap_weight(&cbm, r->cache.cbm_len); 1391fa7d9493SBabu Moger ci = get_cpu_cacheinfo(cpumask_any(&d->cpu_mask)); 1392fa7d9493SBabu Moger for (i = 0; i < ci->num_leaves; i++) { 1393fa7d9493SBabu Moger if (ci->info_list[i].level == r->cache_level) { 1394fa7d9493SBabu Moger size = ci->info_list[i].size / r->cache.cbm_len * num_b; 1395fa7d9493SBabu Moger break; 1396fa7d9493SBabu Moger } 1397fa7d9493SBabu Moger } 1398fa7d9493SBabu Moger 1399fa7d9493SBabu Moger return size; 1400fa7d9493SBabu Moger } 1401fa7d9493SBabu Moger 1402fa7d9493SBabu Moger /** 1403fa7d9493SBabu Moger * rdtgroup_size_show - Display size in bytes of allocated regions 1404fa7d9493SBabu Moger * 1405fa7d9493SBabu Moger * The "size" file mirrors the layout of the "schemata" file, printing the 1406fa7d9493SBabu Moger * size in bytes of each region instead of the capacity bitmask. 1407fa7d9493SBabu Moger * 1408fa7d9493SBabu Moger */ 1409fa7d9493SBabu Moger static int rdtgroup_size_show(struct kernfs_open_file *of, 1410fa7d9493SBabu Moger struct seq_file *s, void *v) 1411fa7d9493SBabu Moger { 1412792e0f6fSJames Morse struct rdt_hw_domain *hw_dom; 1413fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 1414fa7d9493SBabu Moger struct rdt_resource *r; 1415fa7d9493SBabu Moger struct rdt_domain *d; 1416fa7d9493SBabu Moger unsigned int size; 1417fa7d9493SBabu Moger int ret = 0; 1418fa7d9493SBabu Moger bool sep; 1419fa7d9493SBabu Moger u32 ctrl; 1420fa7d9493SBabu Moger 1421fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(of->kn); 1422fa7d9493SBabu Moger if (!rdtgrp) { 1423fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1424fa7d9493SBabu Moger return -ENOENT; 1425fa7d9493SBabu Moger } 1426fa7d9493SBabu Moger 1427fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 1428fa7d9493SBabu Moger if (!rdtgrp->plr->d) { 1429fa7d9493SBabu Moger rdt_last_cmd_clear(); 1430fa7d9493SBabu Moger rdt_last_cmd_puts("Cache domain offline\n"); 1431fa7d9493SBabu Moger ret = -ENODEV; 1432fa7d9493SBabu Moger } else { 1433fa7d9493SBabu Moger seq_printf(s, "%*s:", max_name_width, 1434fa7d9493SBabu Moger rdtgrp->plr->r->name); 1435fa7d9493SBabu Moger size = rdtgroup_cbm_to_size(rdtgrp->plr->r, 1436fa7d9493SBabu Moger rdtgrp->plr->d, 1437fa7d9493SBabu Moger rdtgrp->plr->cbm); 1438fa7d9493SBabu Moger seq_printf(s, "%d=%u\n", rdtgrp->plr->d->id, size); 1439fa7d9493SBabu Moger } 1440fa7d9493SBabu Moger goto out; 1441fa7d9493SBabu Moger } 1442fa7d9493SBabu Moger 1443fa7d9493SBabu Moger for_each_alloc_enabled_rdt_resource(r) { 1444fa7d9493SBabu Moger sep = false; 1445fa7d9493SBabu Moger seq_printf(s, "%*s:", max_name_width, r->name); 1446fa7d9493SBabu Moger list_for_each_entry(d, &r->domains, list) { 1447792e0f6fSJames Morse hw_dom = resctrl_to_arch_dom(d); 1448fa7d9493SBabu Moger if (sep) 1449fa7d9493SBabu Moger seq_putc(s, ';'); 1450fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1451fa7d9493SBabu Moger size = 0; 1452fa7d9493SBabu Moger } else { 1453fa7d9493SBabu Moger ctrl = (!is_mba_sc(r) ? 1454792e0f6fSJames Morse hw_dom->ctrl_val[rdtgrp->closid] : 1455792e0f6fSJames Morse hw_dom->mbps_val[rdtgrp->closid]); 1456fa7d9493SBabu Moger if (r->rid == RDT_RESOURCE_MBA) 1457fa7d9493SBabu Moger size = ctrl; 1458fa7d9493SBabu Moger else 1459fa7d9493SBabu Moger size = rdtgroup_cbm_to_size(r, d, ctrl); 1460fa7d9493SBabu Moger } 1461fa7d9493SBabu Moger seq_printf(s, "%d=%u", d->id, size); 1462fa7d9493SBabu Moger sep = true; 1463fa7d9493SBabu Moger } 1464fa7d9493SBabu Moger seq_putc(s, '\n'); 1465fa7d9493SBabu Moger } 1466fa7d9493SBabu Moger 1467fa7d9493SBabu Moger out: 1468fa7d9493SBabu Moger rdtgroup_kn_unlock(of->kn); 1469fa7d9493SBabu Moger 1470fa7d9493SBabu Moger return ret; 1471fa7d9493SBabu Moger } 1472fa7d9493SBabu Moger 1473fa7d9493SBabu Moger /* rdtgroup information files for one cache resource. */ 1474fa7d9493SBabu Moger static struct rftype res_common_files[] = { 1475fa7d9493SBabu Moger { 1476fa7d9493SBabu Moger .name = "last_cmd_status", 1477fa7d9493SBabu Moger .mode = 0444, 1478fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1479fa7d9493SBabu Moger .seq_show = rdt_last_cmd_status_show, 1480fa7d9493SBabu Moger .fflags = RF_TOP_INFO, 1481fa7d9493SBabu Moger }, 1482fa7d9493SBabu Moger { 1483fa7d9493SBabu Moger .name = "num_closids", 1484fa7d9493SBabu Moger .mode = 0444, 1485fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1486fa7d9493SBabu Moger .seq_show = rdt_num_closids_show, 1487fa7d9493SBabu Moger .fflags = RF_CTRL_INFO, 1488fa7d9493SBabu Moger }, 1489fa7d9493SBabu Moger { 1490fa7d9493SBabu Moger .name = "mon_features", 1491fa7d9493SBabu Moger .mode = 0444, 1492fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1493fa7d9493SBabu Moger .seq_show = rdt_mon_features_show, 1494fa7d9493SBabu Moger .fflags = RF_MON_INFO, 1495fa7d9493SBabu Moger }, 1496fa7d9493SBabu Moger { 1497fa7d9493SBabu Moger .name = "num_rmids", 1498fa7d9493SBabu Moger .mode = 0444, 1499fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1500fa7d9493SBabu Moger .seq_show = rdt_num_rmids_show, 1501fa7d9493SBabu Moger .fflags = RF_MON_INFO, 1502fa7d9493SBabu Moger }, 1503fa7d9493SBabu Moger { 1504fa7d9493SBabu Moger .name = "cbm_mask", 1505fa7d9493SBabu Moger .mode = 0444, 1506fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1507fa7d9493SBabu Moger .seq_show = rdt_default_ctrl_show, 1508fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1509fa7d9493SBabu Moger }, 1510fa7d9493SBabu Moger { 1511fa7d9493SBabu Moger .name = "min_cbm_bits", 1512fa7d9493SBabu Moger .mode = 0444, 1513fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1514fa7d9493SBabu Moger .seq_show = rdt_min_cbm_bits_show, 1515fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1516fa7d9493SBabu Moger }, 1517fa7d9493SBabu Moger { 1518fa7d9493SBabu Moger .name = "shareable_bits", 1519fa7d9493SBabu Moger .mode = 0444, 1520fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1521fa7d9493SBabu Moger .seq_show = rdt_shareable_bits_show, 1522fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1523fa7d9493SBabu Moger }, 1524fa7d9493SBabu Moger { 1525fa7d9493SBabu Moger .name = "bit_usage", 1526fa7d9493SBabu Moger .mode = 0444, 1527fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1528fa7d9493SBabu Moger .seq_show = rdt_bit_usage_show, 1529fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_CACHE, 1530fa7d9493SBabu Moger }, 1531fa7d9493SBabu Moger { 1532fa7d9493SBabu Moger .name = "min_bandwidth", 1533fa7d9493SBabu Moger .mode = 0444, 1534fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1535fa7d9493SBabu Moger .seq_show = rdt_min_bw_show, 1536fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1537fa7d9493SBabu Moger }, 1538fa7d9493SBabu Moger { 1539fa7d9493SBabu Moger .name = "bandwidth_gran", 1540fa7d9493SBabu Moger .mode = 0444, 1541fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1542fa7d9493SBabu Moger .seq_show = rdt_bw_gran_show, 1543fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1544fa7d9493SBabu Moger }, 1545fa7d9493SBabu Moger { 1546fa7d9493SBabu Moger .name = "delay_linear", 1547fa7d9493SBabu Moger .mode = 0444, 1548fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1549fa7d9493SBabu Moger .seq_show = rdt_delay_linear_show, 1550fa7d9493SBabu Moger .fflags = RF_CTRL_INFO | RFTYPE_RES_MB, 1551fa7d9493SBabu Moger }, 155229b6bd41SFenghua Yu /* 155329b6bd41SFenghua Yu * Platform specific which (if any) capabilities are provided by 155429b6bd41SFenghua Yu * thread_throttle_mode. Defer "fflags" initialization to platform 155529b6bd41SFenghua Yu * discovery. 155629b6bd41SFenghua Yu */ 155729b6bd41SFenghua Yu { 155829b6bd41SFenghua Yu .name = "thread_throttle_mode", 155929b6bd41SFenghua Yu .mode = 0444, 156029b6bd41SFenghua Yu .kf_ops = &rdtgroup_kf_single_ops, 156129b6bd41SFenghua Yu .seq_show = rdt_thread_throttle_mode_show, 156229b6bd41SFenghua Yu }, 1563fa7d9493SBabu Moger { 1564fa7d9493SBabu Moger .name = "max_threshold_occupancy", 1565fa7d9493SBabu Moger .mode = 0644, 1566fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1567fa7d9493SBabu Moger .write = max_threshold_occ_write, 1568fa7d9493SBabu Moger .seq_show = max_threshold_occ_show, 1569fa7d9493SBabu Moger .fflags = RF_MON_INFO | RFTYPE_RES_CACHE, 1570fa7d9493SBabu Moger }, 1571fa7d9493SBabu Moger { 1572fa7d9493SBabu Moger .name = "cpus", 1573fa7d9493SBabu Moger .mode = 0644, 1574fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1575fa7d9493SBabu Moger .write = rdtgroup_cpus_write, 1576fa7d9493SBabu Moger .seq_show = rdtgroup_cpus_show, 1577fa7d9493SBabu Moger .fflags = RFTYPE_BASE, 1578fa7d9493SBabu Moger }, 1579fa7d9493SBabu Moger { 1580fa7d9493SBabu Moger .name = "cpus_list", 1581fa7d9493SBabu Moger .mode = 0644, 1582fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1583fa7d9493SBabu Moger .write = rdtgroup_cpus_write, 1584fa7d9493SBabu Moger .seq_show = rdtgroup_cpus_show, 1585fa7d9493SBabu Moger .flags = RFTYPE_FLAGS_CPUS_LIST, 1586fa7d9493SBabu Moger .fflags = RFTYPE_BASE, 1587fa7d9493SBabu Moger }, 1588fa7d9493SBabu Moger { 1589fa7d9493SBabu Moger .name = "tasks", 1590fa7d9493SBabu Moger .mode = 0644, 1591fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1592fa7d9493SBabu Moger .write = rdtgroup_tasks_write, 1593fa7d9493SBabu Moger .seq_show = rdtgroup_tasks_show, 1594fa7d9493SBabu Moger .fflags = RFTYPE_BASE, 1595fa7d9493SBabu Moger }, 1596fa7d9493SBabu Moger { 1597fa7d9493SBabu Moger .name = "schemata", 1598fa7d9493SBabu Moger .mode = 0644, 1599fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1600fa7d9493SBabu Moger .write = rdtgroup_schemata_write, 1601fa7d9493SBabu Moger .seq_show = rdtgroup_schemata_show, 1602fa7d9493SBabu Moger .fflags = RF_CTRL_BASE, 1603fa7d9493SBabu Moger }, 1604fa7d9493SBabu Moger { 1605fa7d9493SBabu Moger .name = "mode", 1606fa7d9493SBabu Moger .mode = 0644, 1607fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1608fa7d9493SBabu Moger .write = rdtgroup_mode_write, 1609fa7d9493SBabu Moger .seq_show = rdtgroup_mode_show, 1610fa7d9493SBabu Moger .fflags = RF_CTRL_BASE, 1611fa7d9493SBabu Moger }, 1612fa7d9493SBabu Moger { 1613fa7d9493SBabu Moger .name = "size", 1614fa7d9493SBabu Moger .mode = 0444, 1615fa7d9493SBabu Moger .kf_ops = &rdtgroup_kf_single_ops, 1616fa7d9493SBabu Moger .seq_show = rdtgroup_size_show, 1617fa7d9493SBabu Moger .fflags = RF_CTRL_BASE, 1618fa7d9493SBabu Moger }, 1619fa7d9493SBabu Moger 1620fa7d9493SBabu Moger }; 1621fa7d9493SBabu Moger 1622fa7d9493SBabu Moger static int rdtgroup_add_files(struct kernfs_node *kn, unsigned long fflags) 1623fa7d9493SBabu Moger { 1624fa7d9493SBabu Moger struct rftype *rfts, *rft; 1625fa7d9493SBabu Moger int ret, len; 1626fa7d9493SBabu Moger 1627fa7d9493SBabu Moger rfts = res_common_files; 1628fa7d9493SBabu Moger len = ARRAY_SIZE(res_common_files); 1629fa7d9493SBabu Moger 1630fa7d9493SBabu Moger lockdep_assert_held(&rdtgroup_mutex); 1631fa7d9493SBabu Moger 1632fa7d9493SBabu Moger for (rft = rfts; rft < rfts + len; rft++) { 163329b6bd41SFenghua Yu if (rft->fflags && ((fflags & rft->fflags) == rft->fflags)) { 1634fa7d9493SBabu Moger ret = rdtgroup_add_file(kn, rft); 1635fa7d9493SBabu Moger if (ret) 1636fa7d9493SBabu Moger goto error; 1637fa7d9493SBabu Moger } 1638fa7d9493SBabu Moger } 1639fa7d9493SBabu Moger 1640fa7d9493SBabu Moger return 0; 1641fa7d9493SBabu Moger error: 1642fa7d9493SBabu Moger pr_warn("Failed to add %s, err=%d\n", rft->name, ret); 1643fa7d9493SBabu Moger while (--rft >= rfts) { 1644fa7d9493SBabu Moger if ((fflags & rft->fflags) == rft->fflags) 1645fa7d9493SBabu Moger kernfs_remove_by_name(kn, rft->name); 1646fa7d9493SBabu Moger } 1647fa7d9493SBabu Moger return ret; 1648fa7d9493SBabu Moger } 1649fa7d9493SBabu Moger 165029b6bd41SFenghua Yu static struct rftype *rdtgroup_get_rftype_by_name(const char *name) 165129b6bd41SFenghua Yu { 165229b6bd41SFenghua Yu struct rftype *rfts, *rft; 165329b6bd41SFenghua Yu int len; 165429b6bd41SFenghua Yu 165529b6bd41SFenghua Yu rfts = res_common_files; 165629b6bd41SFenghua Yu len = ARRAY_SIZE(res_common_files); 165729b6bd41SFenghua Yu 165829b6bd41SFenghua Yu for (rft = rfts; rft < rfts + len; rft++) { 165929b6bd41SFenghua Yu if (!strcmp(rft->name, name)) 166029b6bd41SFenghua Yu return rft; 166129b6bd41SFenghua Yu } 166229b6bd41SFenghua Yu 166329b6bd41SFenghua Yu return NULL; 166429b6bd41SFenghua Yu } 166529b6bd41SFenghua Yu 166629b6bd41SFenghua Yu void __init thread_throttle_mode_init(void) 166729b6bd41SFenghua Yu { 166829b6bd41SFenghua Yu struct rftype *rft; 166929b6bd41SFenghua Yu 167029b6bd41SFenghua Yu rft = rdtgroup_get_rftype_by_name("thread_throttle_mode"); 167129b6bd41SFenghua Yu if (!rft) 167229b6bd41SFenghua Yu return; 167329b6bd41SFenghua Yu 167429b6bd41SFenghua Yu rft->fflags = RF_CTRL_INFO | RFTYPE_RES_MB; 167529b6bd41SFenghua Yu } 167629b6bd41SFenghua Yu 1677fa7d9493SBabu Moger /** 1678fa7d9493SBabu Moger * rdtgroup_kn_mode_restrict - Restrict user access to named resctrl file 1679fa7d9493SBabu Moger * @r: The resource group with which the file is associated. 1680fa7d9493SBabu Moger * @name: Name of the file 1681fa7d9493SBabu Moger * 1682fa7d9493SBabu Moger * The permissions of named resctrl file, directory, or link are modified 1683fa7d9493SBabu Moger * to not allow read, write, or execute by any user. 1684fa7d9493SBabu Moger * 1685fa7d9493SBabu Moger * WARNING: This function is intended to communicate to the user that the 1686fa7d9493SBabu Moger * resctrl file has been locked down - that it is not relevant to the 1687fa7d9493SBabu Moger * particular state the system finds itself in. It should not be relied 1688fa7d9493SBabu Moger * on to protect from user access because after the file's permissions 1689fa7d9493SBabu Moger * are restricted the user can still change the permissions using chmod 1690fa7d9493SBabu Moger * from the command line. 1691fa7d9493SBabu Moger * 1692fa7d9493SBabu Moger * Return: 0 on success, <0 on failure. 1693fa7d9493SBabu Moger */ 1694fa7d9493SBabu Moger int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name) 1695fa7d9493SBabu Moger { 1696fa7d9493SBabu Moger struct iattr iattr = {.ia_valid = ATTR_MODE,}; 1697fa7d9493SBabu Moger struct kernfs_node *kn; 1698fa7d9493SBabu Moger int ret = 0; 1699fa7d9493SBabu Moger 1700fa7d9493SBabu Moger kn = kernfs_find_and_get_ns(r->kn, name, NULL); 1701fa7d9493SBabu Moger if (!kn) 1702fa7d9493SBabu Moger return -ENOENT; 1703fa7d9493SBabu Moger 1704fa7d9493SBabu Moger switch (kernfs_type(kn)) { 1705fa7d9493SBabu Moger case KERNFS_DIR: 1706fa7d9493SBabu Moger iattr.ia_mode = S_IFDIR; 1707fa7d9493SBabu Moger break; 1708fa7d9493SBabu Moger case KERNFS_FILE: 1709fa7d9493SBabu Moger iattr.ia_mode = S_IFREG; 1710fa7d9493SBabu Moger break; 1711fa7d9493SBabu Moger case KERNFS_LINK: 1712fa7d9493SBabu Moger iattr.ia_mode = S_IFLNK; 1713fa7d9493SBabu Moger break; 1714fa7d9493SBabu Moger } 1715fa7d9493SBabu Moger 1716fa7d9493SBabu Moger ret = kernfs_setattr(kn, &iattr); 1717fa7d9493SBabu Moger kernfs_put(kn); 1718fa7d9493SBabu Moger return ret; 1719fa7d9493SBabu Moger } 1720fa7d9493SBabu Moger 1721fa7d9493SBabu Moger /** 1722fa7d9493SBabu Moger * rdtgroup_kn_mode_restore - Restore user access to named resctrl file 1723fa7d9493SBabu Moger * @r: The resource group with which the file is associated. 1724fa7d9493SBabu Moger * @name: Name of the file 1725fa7d9493SBabu Moger * @mask: Mask of permissions that should be restored 1726fa7d9493SBabu Moger * 1727fa7d9493SBabu Moger * Restore the permissions of the named file. If @name is a directory the 1728fa7d9493SBabu Moger * permissions of its parent will be used. 1729fa7d9493SBabu Moger * 1730fa7d9493SBabu Moger * Return: 0 on success, <0 on failure. 1731fa7d9493SBabu Moger */ 1732fa7d9493SBabu Moger int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, 1733fa7d9493SBabu Moger umode_t mask) 1734fa7d9493SBabu Moger { 1735fa7d9493SBabu Moger struct iattr iattr = {.ia_valid = ATTR_MODE,}; 1736fa7d9493SBabu Moger struct kernfs_node *kn, *parent; 1737fa7d9493SBabu Moger struct rftype *rfts, *rft; 1738fa7d9493SBabu Moger int ret, len; 1739fa7d9493SBabu Moger 1740fa7d9493SBabu Moger rfts = res_common_files; 1741fa7d9493SBabu Moger len = ARRAY_SIZE(res_common_files); 1742fa7d9493SBabu Moger 1743fa7d9493SBabu Moger for (rft = rfts; rft < rfts + len; rft++) { 1744fa7d9493SBabu Moger if (!strcmp(rft->name, name)) 1745fa7d9493SBabu Moger iattr.ia_mode = rft->mode & mask; 1746fa7d9493SBabu Moger } 1747fa7d9493SBabu Moger 1748fa7d9493SBabu Moger kn = kernfs_find_and_get_ns(r->kn, name, NULL); 1749fa7d9493SBabu Moger if (!kn) 1750fa7d9493SBabu Moger return -ENOENT; 1751fa7d9493SBabu Moger 1752fa7d9493SBabu Moger switch (kernfs_type(kn)) { 1753fa7d9493SBabu Moger case KERNFS_DIR: 1754fa7d9493SBabu Moger parent = kernfs_get_parent(kn); 1755fa7d9493SBabu Moger if (parent) { 1756fa7d9493SBabu Moger iattr.ia_mode |= parent->mode; 1757fa7d9493SBabu Moger kernfs_put(parent); 1758fa7d9493SBabu Moger } 1759fa7d9493SBabu Moger iattr.ia_mode |= S_IFDIR; 1760fa7d9493SBabu Moger break; 1761fa7d9493SBabu Moger case KERNFS_FILE: 1762fa7d9493SBabu Moger iattr.ia_mode |= S_IFREG; 1763fa7d9493SBabu Moger break; 1764fa7d9493SBabu Moger case KERNFS_LINK: 1765fa7d9493SBabu Moger iattr.ia_mode |= S_IFLNK; 1766fa7d9493SBabu Moger break; 1767fa7d9493SBabu Moger } 1768fa7d9493SBabu Moger 1769fa7d9493SBabu Moger ret = kernfs_setattr(kn, &iattr); 1770fa7d9493SBabu Moger kernfs_put(kn); 1771fa7d9493SBabu Moger return ret; 1772fa7d9493SBabu Moger } 1773fa7d9493SBabu Moger 1774fa7d9493SBabu Moger static int rdtgroup_mkdir_info_resdir(struct rdt_resource *r, char *name, 1775fa7d9493SBabu Moger unsigned long fflags) 1776fa7d9493SBabu Moger { 1777fa7d9493SBabu Moger struct kernfs_node *kn_subdir; 1778fa7d9493SBabu Moger int ret; 1779fa7d9493SBabu Moger 1780fa7d9493SBabu Moger kn_subdir = kernfs_create_dir(kn_info, name, 1781fa7d9493SBabu Moger kn_info->mode, r); 1782fa7d9493SBabu Moger if (IS_ERR(kn_subdir)) 1783fa7d9493SBabu Moger return PTR_ERR(kn_subdir); 1784fa7d9493SBabu Moger 1785fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn_subdir); 1786fa7d9493SBabu Moger if (ret) 1787fa7d9493SBabu Moger return ret; 1788fa7d9493SBabu Moger 1789fa7d9493SBabu Moger ret = rdtgroup_add_files(kn_subdir, fflags); 1790fa7d9493SBabu Moger if (!ret) 1791fa7d9493SBabu Moger kernfs_activate(kn_subdir); 1792fa7d9493SBabu Moger 1793fa7d9493SBabu Moger return ret; 1794fa7d9493SBabu Moger } 1795fa7d9493SBabu Moger 1796fa7d9493SBabu Moger static int rdtgroup_create_info_dir(struct kernfs_node *parent_kn) 1797fa7d9493SBabu Moger { 1798fa7d9493SBabu Moger struct rdt_resource *r; 1799fa7d9493SBabu Moger unsigned long fflags; 1800fa7d9493SBabu Moger char name[32]; 1801fa7d9493SBabu Moger int ret; 1802fa7d9493SBabu Moger 1803fa7d9493SBabu Moger /* create the directory */ 1804fa7d9493SBabu Moger kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL); 1805fa7d9493SBabu Moger if (IS_ERR(kn_info)) 1806fa7d9493SBabu Moger return PTR_ERR(kn_info); 1807fa7d9493SBabu Moger 1808fa7d9493SBabu Moger ret = rdtgroup_add_files(kn_info, RF_TOP_INFO); 1809fa7d9493SBabu Moger if (ret) 1810fa7d9493SBabu Moger goto out_destroy; 1811fa7d9493SBabu Moger 1812fa7d9493SBabu Moger for_each_alloc_enabled_rdt_resource(r) { 1813fa7d9493SBabu Moger fflags = r->fflags | RF_CTRL_INFO; 1814fa7d9493SBabu Moger ret = rdtgroup_mkdir_info_resdir(r, r->name, fflags); 1815fa7d9493SBabu Moger if (ret) 1816fa7d9493SBabu Moger goto out_destroy; 1817fa7d9493SBabu Moger } 1818fa7d9493SBabu Moger 1819fa7d9493SBabu Moger for_each_mon_enabled_rdt_resource(r) { 1820fa7d9493SBabu Moger fflags = r->fflags | RF_MON_INFO; 1821fa7d9493SBabu Moger sprintf(name, "%s_MON", r->name); 1822fa7d9493SBabu Moger ret = rdtgroup_mkdir_info_resdir(r, name, fflags); 1823fa7d9493SBabu Moger if (ret) 1824fa7d9493SBabu Moger goto out_destroy; 1825fa7d9493SBabu Moger } 1826fa7d9493SBabu Moger 1827fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn_info); 1828fa7d9493SBabu Moger if (ret) 1829fa7d9493SBabu Moger goto out_destroy; 1830fa7d9493SBabu Moger 1831fa7d9493SBabu Moger kernfs_activate(kn_info); 1832fa7d9493SBabu Moger 1833fa7d9493SBabu Moger return 0; 1834fa7d9493SBabu Moger 1835fa7d9493SBabu Moger out_destroy: 1836fa7d9493SBabu Moger kernfs_remove(kn_info); 1837fa7d9493SBabu Moger return ret; 1838fa7d9493SBabu Moger } 1839fa7d9493SBabu Moger 1840fa7d9493SBabu Moger static int 1841fa7d9493SBabu Moger mongroup_create_dir(struct kernfs_node *parent_kn, struct rdtgroup *prgrp, 1842fa7d9493SBabu Moger char *name, struct kernfs_node **dest_kn) 1843fa7d9493SBabu Moger { 1844fa7d9493SBabu Moger struct kernfs_node *kn; 1845fa7d9493SBabu Moger int ret; 1846fa7d9493SBabu Moger 1847fa7d9493SBabu Moger /* create the directory */ 1848fa7d9493SBabu Moger kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 1849fa7d9493SBabu Moger if (IS_ERR(kn)) 1850fa7d9493SBabu Moger return PTR_ERR(kn); 1851fa7d9493SBabu Moger 1852fa7d9493SBabu Moger if (dest_kn) 1853fa7d9493SBabu Moger *dest_kn = kn; 1854fa7d9493SBabu Moger 1855fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 1856fa7d9493SBabu Moger if (ret) 1857fa7d9493SBabu Moger goto out_destroy; 1858fa7d9493SBabu Moger 1859fa7d9493SBabu Moger kernfs_activate(kn); 1860fa7d9493SBabu Moger 1861fa7d9493SBabu Moger return 0; 1862fa7d9493SBabu Moger 1863fa7d9493SBabu Moger out_destroy: 1864fa7d9493SBabu Moger kernfs_remove(kn); 1865fa7d9493SBabu Moger return ret; 1866fa7d9493SBabu Moger } 1867fa7d9493SBabu Moger 1868fa7d9493SBabu Moger static void l3_qos_cfg_update(void *arg) 1869fa7d9493SBabu Moger { 1870fa7d9493SBabu Moger bool *enable = arg; 1871fa7d9493SBabu Moger 1872aa50453aSBabu Moger wrmsrl(MSR_IA32_L3_QOS_CFG, *enable ? L3_QOS_CDP_ENABLE : 0ULL); 1873fa7d9493SBabu Moger } 1874fa7d9493SBabu Moger 1875fa7d9493SBabu Moger static void l2_qos_cfg_update(void *arg) 1876fa7d9493SBabu Moger { 1877fa7d9493SBabu Moger bool *enable = arg; 1878fa7d9493SBabu Moger 1879aa50453aSBabu Moger wrmsrl(MSR_IA32_L2_QOS_CFG, *enable ? L2_QOS_CDP_ENABLE : 0ULL); 1880fa7d9493SBabu Moger } 1881fa7d9493SBabu Moger 1882fa7d9493SBabu Moger static inline bool is_mba_linear(void) 1883fa7d9493SBabu Moger { 188463c8b123SJames Morse return rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl.membw.delay_linear; 1885fa7d9493SBabu Moger } 1886fa7d9493SBabu Moger 1887fa7d9493SBabu Moger static int set_cache_qos_cfg(int level, bool enable) 1888fa7d9493SBabu Moger { 1889fa7d9493SBabu Moger void (*update)(void *arg); 1890fa7d9493SBabu Moger struct rdt_resource *r_l; 1891fa7d9493SBabu Moger cpumask_var_t cpu_mask; 1892fa7d9493SBabu Moger struct rdt_domain *d; 1893fa7d9493SBabu Moger int cpu; 1894fa7d9493SBabu Moger 1895fa7d9493SBabu Moger if (level == RDT_RESOURCE_L3) 1896fa7d9493SBabu Moger update = l3_qos_cfg_update; 1897fa7d9493SBabu Moger else if (level == RDT_RESOURCE_L2) 1898fa7d9493SBabu Moger update = l2_qos_cfg_update; 1899fa7d9493SBabu Moger else 1900fa7d9493SBabu Moger return -EINVAL; 1901fa7d9493SBabu Moger 1902ab6a2114SShakeel Butt if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL)) 1903ab6a2114SShakeel Butt return -ENOMEM; 1904ab6a2114SShakeel Butt 190563c8b123SJames Morse r_l = &rdt_resources_all[level].r_resctrl; 1906fa7d9493SBabu Moger list_for_each_entry(d, &r_l->domains, list) { 1907fae3a13dSBabu Moger if (r_l->cache.arch_has_per_cpu_cfg) 1908fae3a13dSBabu Moger /* Pick all the CPUs in the domain instance */ 1909fae3a13dSBabu Moger for_each_cpu(cpu, &d->cpu_mask) 1910fae3a13dSBabu Moger cpumask_set_cpu(cpu, cpu_mask); 1911fae3a13dSBabu Moger else 1912fa7d9493SBabu Moger /* Pick one CPU from each domain instance to update MSR */ 1913fa7d9493SBabu Moger cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask); 1914fa7d9493SBabu Moger } 1915fa7d9493SBabu Moger cpu = get_cpu(); 1916fa7d9493SBabu Moger /* Update QOS_CFG MSR on this cpu if it's in cpu_mask. */ 1917fa7d9493SBabu Moger if (cpumask_test_cpu(cpu, cpu_mask)) 1918fa7d9493SBabu Moger update(&enable); 1919fa7d9493SBabu Moger /* Update QOS_CFG MSR on all other cpus in cpu_mask. */ 1920fa7d9493SBabu Moger smp_call_function_many(cpu_mask, update, &enable, 1); 1921fa7d9493SBabu Moger put_cpu(); 1922fa7d9493SBabu Moger 1923fa7d9493SBabu Moger free_cpumask_var(cpu_mask); 1924fa7d9493SBabu Moger 1925fa7d9493SBabu Moger return 0; 1926fa7d9493SBabu Moger } 1927fa7d9493SBabu Moger 19289fe04507SJames Morse /* Restore the qos cfg state when a domain comes online */ 19299fe04507SJames Morse void rdt_domain_reconfigure_cdp(struct rdt_resource *r) 19309fe04507SJames Morse { 19319fe04507SJames Morse if (!r->alloc_capable) 19329fe04507SJames Morse return; 19339fe04507SJames Morse 193463c8b123SJames Morse if (r == &rdt_resources_all[RDT_RESOURCE_L2DATA].r_resctrl) 19359fe04507SJames Morse l2_qos_cfg_update(&r->alloc_enabled); 19369fe04507SJames Morse 193763c8b123SJames Morse if (r == &rdt_resources_all[RDT_RESOURCE_L3DATA].r_resctrl) 19389fe04507SJames Morse l3_qos_cfg_update(&r->alloc_enabled); 19399fe04507SJames Morse } 19409fe04507SJames Morse 1941fa7d9493SBabu Moger /* 1942fa7d9493SBabu Moger * Enable or disable the MBA software controller 1943fa7d9493SBabu Moger * which helps user specify bandwidth in MBps. 1944fa7d9493SBabu Moger * MBA software controller is supported only if 1945fa7d9493SBabu Moger * MBM is supported and MBA is in linear scale. 1946fa7d9493SBabu Moger */ 1947fa7d9493SBabu Moger static int set_mba_sc(bool mba_sc) 1948fa7d9493SBabu Moger { 194963c8b123SJames Morse struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl; 1950792e0f6fSJames Morse struct rdt_hw_domain *hw_dom; 1951fa7d9493SBabu Moger struct rdt_domain *d; 1952fa7d9493SBabu Moger 1953fa7d9493SBabu Moger if (!is_mbm_enabled() || !is_mba_linear() || 1954fa7d9493SBabu Moger mba_sc == is_mba_sc(r)) 1955fa7d9493SBabu Moger return -EINVAL; 1956fa7d9493SBabu Moger 1957fa7d9493SBabu Moger r->membw.mba_sc = mba_sc; 1958792e0f6fSJames Morse list_for_each_entry(d, &r->domains, list) { 1959792e0f6fSJames Morse hw_dom = resctrl_to_arch_dom(d); 1960792e0f6fSJames Morse setup_default_ctrlval(r, hw_dom->ctrl_val, hw_dom->mbps_val); 1961792e0f6fSJames Morse } 1962fa7d9493SBabu Moger 1963fa7d9493SBabu Moger return 0; 1964fa7d9493SBabu Moger } 1965fa7d9493SBabu Moger 1966fa7d9493SBabu Moger static int cdp_enable(int level, int data_type, int code_type) 1967fa7d9493SBabu Moger { 196863c8b123SJames Morse struct rdt_resource *r_ldata = &rdt_resources_all[data_type].r_resctrl; 196963c8b123SJames Morse struct rdt_resource *r_lcode = &rdt_resources_all[code_type].r_resctrl; 197063c8b123SJames Morse struct rdt_resource *r_l = &rdt_resources_all[level].r_resctrl; 1971fa7d9493SBabu Moger int ret; 1972fa7d9493SBabu Moger 1973fa7d9493SBabu Moger if (!r_l->alloc_capable || !r_ldata->alloc_capable || 1974fa7d9493SBabu Moger !r_lcode->alloc_capable) 1975fa7d9493SBabu Moger return -EINVAL; 1976fa7d9493SBabu Moger 1977fa7d9493SBabu Moger ret = set_cache_qos_cfg(level, true); 1978fa7d9493SBabu Moger if (!ret) { 1979fa7d9493SBabu Moger r_l->alloc_enabled = false; 1980fa7d9493SBabu Moger r_ldata->alloc_enabled = true; 1981fa7d9493SBabu Moger r_lcode->alloc_enabled = true; 1982fa7d9493SBabu Moger } 1983fa7d9493SBabu Moger return ret; 1984fa7d9493SBabu Moger } 1985fa7d9493SBabu Moger 1986fa7d9493SBabu Moger static int cdpl3_enable(void) 1987fa7d9493SBabu Moger { 1988fa7d9493SBabu Moger return cdp_enable(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA, 1989fa7d9493SBabu Moger RDT_RESOURCE_L3CODE); 1990fa7d9493SBabu Moger } 1991fa7d9493SBabu Moger 1992fa7d9493SBabu Moger static int cdpl2_enable(void) 1993fa7d9493SBabu Moger { 1994fa7d9493SBabu Moger return cdp_enable(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA, 1995fa7d9493SBabu Moger RDT_RESOURCE_L2CODE); 1996fa7d9493SBabu Moger } 1997fa7d9493SBabu Moger 1998fa7d9493SBabu Moger static void cdp_disable(int level, int data_type, int code_type) 1999fa7d9493SBabu Moger { 200063c8b123SJames Morse struct rdt_resource *r = &rdt_resources_all[level].r_resctrl; 2001fa7d9493SBabu Moger 2002fa7d9493SBabu Moger r->alloc_enabled = r->alloc_capable; 2003fa7d9493SBabu Moger 200463c8b123SJames Morse if (rdt_resources_all[data_type].r_resctrl.alloc_enabled) { 200563c8b123SJames Morse rdt_resources_all[data_type].r_resctrl.alloc_enabled = false; 200663c8b123SJames Morse rdt_resources_all[code_type].r_resctrl.alloc_enabled = false; 2007fa7d9493SBabu Moger set_cache_qos_cfg(level, false); 2008fa7d9493SBabu Moger } 2009fa7d9493SBabu Moger } 2010fa7d9493SBabu Moger 2011fa7d9493SBabu Moger static void cdpl3_disable(void) 2012fa7d9493SBabu Moger { 2013fa7d9493SBabu Moger cdp_disable(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA, RDT_RESOURCE_L3CODE); 2014fa7d9493SBabu Moger } 2015fa7d9493SBabu Moger 2016fa7d9493SBabu Moger static void cdpl2_disable(void) 2017fa7d9493SBabu Moger { 2018fa7d9493SBabu Moger cdp_disable(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA, RDT_RESOURCE_L2CODE); 2019fa7d9493SBabu Moger } 2020fa7d9493SBabu Moger 2021fa7d9493SBabu Moger static void cdp_disable_all(void) 2022fa7d9493SBabu Moger { 202363c8b123SJames Morse if (rdt_resources_all[RDT_RESOURCE_L3DATA].r_resctrl.alloc_enabled) 2024fa7d9493SBabu Moger cdpl3_disable(); 202563c8b123SJames Morse if (rdt_resources_all[RDT_RESOURCE_L2DATA].r_resctrl.alloc_enabled) 2026fa7d9493SBabu Moger cdpl2_disable(); 2027fa7d9493SBabu Moger } 2028fa7d9493SBabu Moger 2029fa7d9493SBabu Moger /* 2030fa7d9493SBabu Moger * We don't allow rdtgroup directories to be created anywhere 2031fa7d9493SBabu Moger * except the root directory. Thus when looking for the rdtgroup 2032fa7d9493SBabu Moger * structure for a kernfs node we are either looking at a directory, 2033fa7d9493SBabu Moger * in which case the rdtgroup structure is pointed at by the "priv" 2034fa7d9493SBabu Moger * field, otherwise we have a file, and need only look to the parent 2035fa7d9493SBabu Moger * to find the rdtgroup. 2036fa7d9493SBabu Moger */ 2037fa7d9493SBabu Moger static struct rdtgroup *kernfs_to_rdtgroup(struct kernfs_node *kn) 2038fa7d9493SBabu Moger { 2039fa7d9493SBabu Moger if (kernfs_type(kn) == KERNFS_DIR) { 2040fa7d9493SBabu Moger /* 2041fa7d9493SBabu Moger * All the resource directories use "kn->priv" 2042fa7d9493SBabu Moger * to point to the "struct rdtgroup" for the 2043fa7d9493SBabu Moger * resource. "info" and its subdirectories don't 2044fa7d9493SBabu Moger * have rdtgroup structures, so return NULL here. 2045fa7d9493SBabu Moger */ 2046fa7d9493SBabu Moger if (kn == kn_info || kn->parent == kn_info) 2047fa7d9493SBabu Moger return NULL; 2048fa7d9493SBabu Moger else 2049fa7d9493SBabu Moger return kn->priv; 2050fa7d9493SBabu Moger } else { 2051fa7d9493SBabu Moger return kn->parent->priv; 2052fa7d9493SBabu Moger } 2053fa7d9493SBabu Moger } 2054fa7d9493SBabu Moger 2055fa7d9493SBabu Moger struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn) 2056fa7d9493SBabu Moger { 2057fa7d9493SBabu Moger struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2058fa7d9493SBabu Moger 2059fa7d9493SBabu Moger if (!rdtgrp) 2060fa7d9493SBabu Moger return NULL; 2061fa7d9493SBabu Moger 2062fa7d9493SBabu Moger atomic_inc(&rdtgrp->waitcount); 2063fa7d9493SBabu Moger kernfs_break_active_protection(kn); 2064fa7d9493SBabu Moger 2065fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 2066fa7d9493SBabu Moger 2067fa7d9493SBabu Moger /* Was this group deleted while we waited? */ 2068fa7d9493SBabu Moger if (rdtgrp->flags & RDT_DELETED) 2069fa7d9493SBabu Moger return NULL; 2070fa7d9493SBabu Moger 2071fa7d9493SBabu Moger return rdtgrp; 2072fa7d9493SBabu Moger } 2073fa7d9493SBabu Moger 2074fa7d9493SBabu Moger void rdtgroup_kn_unlock(struct kernfs_node *kn) 2075fa7d9493SBabu Moger { 2076fa7d9493SBabu Moger struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2077fa7d9493SBabu Moger 2078fa7d9493SBabu Moger if (!rdtgrp) 2079fa7d9493SBabu Moger return; 2080fa7d9493SBabu Moger 2081fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 2082fa7d9493SBabu Moger 2083fa7d9493SBabu Moger if (atomic_dec_and_test(&rdtgrp->waitcount) && 2084fa7d9493SBabu Moger (rdtgrp->flags & RDT_DELETED)) { 2085fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2086fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2087fa7d9493SBabu Moger rdtgroup_pseudo_lock_remove(rdtgrp); 2088fa7d9493SBabu Moger kernfs_unbreak_active_protection(kn); 208975899924SXiaochen Shen rdtgroup_remove(rdtgrp); 2090fa7d9493SBabu Moger } else { 2091fa7d9493SBabu Moger kernfs_unbreak_active_protection(kn); 2092fa7d9493SBabu Moger } 2093fa7d9493SBabu Moger } 2094fa7d9493SBabu Moger 2095fa7d9493SBabu Moger static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2096fa7d9493SBabu Moger struct rdtgroup *prgrp, 2097fa7d9493SBabu Moger struct kernfs_node **mon_data_kn); 2098fa7d9493SBabu Moger 209923bf1b6bSDavid Howells static int rdt_enable_ctx(struct rdt_fs_context *ctx) 2100fa7d9493SBabu Moger { 210123bf1b6bSDavid Howells int ret = 0; 210223bf1b6bSDavid Howells 210323bf1b6bSDavid Howells if (ctx->enable_cdpl2) 210423bf1b6bSDavid Howells ret = cdpl2_enable(); 210523bf1b6bSDavid Howells 210623bf1b6bSDavid Howells if (!ret && ctx->enable_cdpl3) 210723bf1b6bSDavid Howells ret = cdpl3_enable(); 210823bf1b6bSDavid Howells 210923bf1b6bSDavid Howells if (!ret && ctx->enable_mba_mbps) 211023bf1b6bSDavid Howells ret = set_mba_sc(true); 211123bf1b6bSDavid Howells 211223bf1b6bSDavid Howells return ret; 211323bf1b6bSDavid Howells } 211423bf1b6bSDavid Howells 2115*cdb9ebc9SJames Morse static int schemata_list_create(void) 2116*cdb9ebc9SJames Morse { 2117*cdb9ebc9SJames Morse struct resctrl_schema *s; 2118*cdb9ebc9SJames Morse struct rdt_resource *r; 2119*cdb9ebc9SJames Morse 2120*cdb9ebc9SJames Morse for_each_alloc_enabled_rdt_resource(r) { 2121*cdb9ebc9SJames Morse s = kzalloc(sizeof(*s), GFP_KERNEL); 2122*cdb9ebc9SJames Morse if (!s) 2123*cdb9ebc9SJames Morse return -ENOMEM; 2124*cdb9ebc9SJames Morse 2125*cdb9ebc9SJames Morse s->res = r; 2126*cdb9ebc9SJames Morse 2127*cdb9ebc9SJames Morse INIT_LIST_HEAD(&s->list); 2128*cdb9ebc9SJames Morse list_add(&s->list, &resctrl_schema_all); 2129*cdb9ebc9SJames Morse } 2130*cdb9ebc9SJames Morse 2131*cdb9ebc9SJames Morse return 0; 2132*cdb9ebc9SJames Morse } 2133*cdb9ebc9SJames Morse 2134*cdb9ebc9SJames Morse static void schemata_list_destroy(void) 2135*cdb9ebc9SJames Morse { 2136*cdb9ebc9SJames Morse struct resctrl_schema *s, *tmp; 2137*cdb9ebc9SJames Morse 2138*cdb9ebc9SJames Morse list_for_each_entry_safe(s, tmp, &resctrl_schema_all, list) { 2139*cdb9ebc9SJames Morse list_del(&s->list); 2140*cdb9ebc9SJames Morse kfree(s); 2141*cdb9ebc9SJames Morse } 2142*cdb9ebc9SJames Morse } 2143*cdb9ebc9SJames Morse 214423bf1b6bSDavid Howells static int rdt_get_tree(struct fs_context *fc) 214523bf1b6bSDavid Howells { 214623bf1b6bSDavid Howells struct rdt_fs_context *ctx = rdt_fc2context(fc); 2147fa7d9493SBabu Moger struct rdt_domain *dom; 2148fa7d9493SBabu Moger struct rdt_resource *r; 2149fa7d9493SBabu Moger int ret; 2150fa7d9493SBabu Moger 2151fa7d9493SBabu Moger cpus_read_lock(); 2152fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 2153fa7d9493SBabu Moger /* 2154fa7d9493SBabu Moger * resctrl file system can only be mounted once. 2155fa7d9493SBabu Moger */ 2156fa7d9493SBabu Moger if (static_branch_unlikely(&rdt_enable_key)) { 215723bf1b6bSDavid Howells ret = -EBUSY; 2158fa7d9493SBabu Moger goto out; 2159fa7d9493SBabu Moger } 2160fa7d9493SBabu Moger 216123bf1b6bSDavid Howells ret = rdt_enable_ctx(ctx); 216223bf1b6bSDavid Howells if (ret < 0) 2163fa7d9493SBabu Moger goto out_cdp; 2164fa7d9493SBabu Moger 2165*cdb9ebc9SJames Morse ret = schemata_list_create(); 2166*cdb9ebc9SJames Morse if (ret) { 2167*cdb9ebc9SJames Morse schemata_list_destroy(); 2168*cdb9ebc9SJames Morse goto out_mba; 2169*cdb9ebc9SJames Morse } 2170*cdb9ebc9SJames Morse 2171fa7d9493SBabu Moger closid_init(); 2172fa7d9493SBabu Moger 2173fa7d9493SBabu Moger ret = rdtgroup_create_info_dir(rdtgroup_default.kn); 217423bf1b6bSDavid Howells if (ret < 0) 2175*cdb9ebc9SJames Morse goto out_schemata_free; 2176fa7d9493SBabu Moger 2177fa7d9493SBabu Moger if (rdt_mon_capable) { 2178fa7d9493SBabu Moger ret = mongroup_create_dir(rdtgroup_default.kn, 2179334b0f4eSXiaochen Shen &rdtgroup_default, "mon_groups", 2180fa7d9493SBabu Moger &kn_mongrp); 218123bf1b6bSDavid Howells if (ret < 0) 2182fa7d9493SBabu Moger goto out_info; 2183fa7d9493SBabu Moger 2184fa7d9493SBabu Moger ret = mkdir_mondata_all(rdtgroup_default.kn, 2185fa7d9493SBabu Moger &rdtgroup_default, &kn_mondata); 218623bf1b6bSDavid Howells if (ret < 0) 2187fa7d9493SBabu Moger goto out_mongrp; 2188fa7d9493SBabu Moger rdtgroup_default.mon.mon_data_kn = kn_mondata; 2189fa7d9493SBabu Moger } 2190fa7d9493SBabu Moger 2191fa7d9493SBabu Moger ret = rdt_pseudo_lock_init(); 219223bf1b6bSDavid Howells if (ret) 2193fa7d9493SBabu Moger goto out_mondata; 2194fa7d9493SBabu Moger 219523bf1b6bSDavid Howells ret = kernfs_get_tree(fc); 219623bf1b6bSDavid Howells if (ret < 0) 2197fa7d9493SBabu Moger goto out_psl; 2198fa7d9493SBabu Moger 2199fa7d9493SBabu Moger if (rdt_alloc_capable) 2200fa7d9493SBabu Moger static_branch_enable_cpuslocked(&rdt_alloc_enable_key); 2201fa7d9493SBabu Moger if (rdt_mon_capable) 2202fa7d9493SBabu Moger static_branch_enable_cpuslocked(&rdt_mon_enable_key); 2203fa7d9493SBabu Moger 2204fa7d9493SBabu Moger if (rdt_alloc_capable || rdt_mon_capable) 2205fa7d9493SBabu Moger static_branch_enable_cpuslocked(&rdt_enable_key); 2206fa7d9493SBabu Moger 2207fa7d9493SBabu Moger if (is_mbm_enabled()) { 220863c8b123SJames Morse r = &rdt_resources_all[RDT_RESOURCE_L3].r_resctrl; 2209fa7d9493SBabu Moger list_for_each_entry(dom, &r->domains, list) 2210fa7d9493SBabu Moger mbm_setup_overflow_handler(dom, MBM_OVERFLOW_INTERVAL); 2211fa7d9493SBabu Moger } 2212fa7d9493SBabu Moger 2213fa7d9493SBabu Moger goto out; 2214fa7d9493SBabu Moger 2215fa7d9493SBabu Moger out_psl: 2216fa7d9493SBabu Moger rdt_pseudo_lock_release(); 2217fa7d9493SBabu Moger out_mondata: 2218fa7d9493SBabu Moger if (rdt_mon_capable) 2219fa7d9493SBabu Moger kernfs_remove(kn_mondata); 2220fa7d9493SBabu Moger out_mongrp: 2221fa7d9493SBabu Moger if (rdt_mon_capable) 2222fa7d9493SBabu Moger kernfs_remove(kn_mongrp); 2223fa7d9493SBabu Moger out_info: 2224fa7d9493SBabu Moger kernfs_remove(kn_info); 2225*cdb9ebc9SJames Morse out_schemata_free: 2226*cdb9ebc9SJames Morse schemata_list_destroy(); 222723bf1b6bSDavid Howells out_mba: 222823bf1b6bSDavid Howells if (ctx->enable_mba_mbps) 222923bf1b6bSDavid Howells set_mba_sc(false); 2230fa7d9493SBabu Moger out_cdp: 2231fa7d9493SBabu Moger cdp_disable_all(); 2232fa7d9493SBabu Moger out: 2233fa7d9493SBabu Moger rdt_last_cmd_clear(); 2234fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 2235fa7d9493SBabu Moger cpus_read_unlock(); 223623bf1b6bSDavid Howells return ret; 223723bf1b6bSDavid Howells } 2238fa7d9493SBabu Moger 223923bf1b6bSDavid Howells enum rdt_param { 224023bf1b6bSDavid Howells Opt_cdp, 224123bf1b6bSDavid Howells Opt_cdpl2, 2242faa3604eSXiaochen Shen Opt_mba_mbps, 224323bf1b6bSDavid Howells nr__rdt_params 224423bf1b6bSDavid Howells }; 224523bf1b6bSDavid Howells 2246d7167b14SAl Viro static const struct fs_parameter_spec rdt_fs_parameters[] = { 224723bf1b6bSDavid Howells fsparam_flag("cdp", Opt_cdp), 224823bf1b6bSDavid Howells fsparam_flag("cdpl2", Opt_cdpl2), 2249faa3604eSXiaochen Shen fsparam_flag("mba_MBps", Opt_mba_mbps), 225023bf1b6bSDavid Howells {} 225123bf1b6bSDavid Howells }; 225223bf1b6bSDavid Howells 225323bf1b6bSDavid Howells static int rdt_parse_param(struct fs_context *fc, struct fs_parameter *param) 225423bf1b6bSDavid Howells { 225523bf1b6bSDavid Howells struct rdt_fs_context *ctx = rdt_fc2context(fc); 225623bf1b6bSDavid Howells struct fs_parse_result result; 225723bf1b6bSDavid Howells int opt; 225823bf1b6bSDavid Howells 2259d7167b14SAl Viro opt = fs_parse(fc, rdt_fs_parameters, param, &result); 226023bf1b6bSDavid Howells if (opt < 0) 226123bf1b6bSDavid Howells return opt; 226223bf1b6bSDavid Howells 226323bf1b6bSDavid Howells switch (opt) { 226423bf1b6bSDavid Howells case Opt_cdp: 226523bf1b6bSDavid Howells ctx->enable_cdpl3 = true; 226623bf1b6bSDavid Howells return 0; 226723bf1b6bSDavid Howells case Opt_cdpl2: 226823bf1b6bSDavid Howells ctx->enable_cdpl2 = true; 226923bf1b6bSDavid Howells return 0; 2270faa3604eSXiaochen Shen case Opt_mba_mbps: 227123bf1b6bSDavid Howells if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) 227223bf1b6bSDavid Howells return -EINVAL; 227323bf1b6bSDavid Howells ctx->enable_mba_mbps = true; 227423bf1b6bSDavid Howells return 0; 227523bf1b6bSDavid Howells } 227623bf1b6bSDavid Howells 227723bf1b6bSDavid Howells return -EINVAL; 227823bf1b6bSDavid Howells } 227923bf1b6bSDavid Howells 228023bf1b6bSDavid Howells static void rdt_fs_context_free(struct fs_context *fc) 228123bf1b6bSDavid Howells { 228223bf1b6bSDavid Howells struct rdt_fs_context *ctx = rdt_fc2context(fc); 228323bf1b6bSDavid Howells 228423bf1b6bSDavid Howells kernfs_free_fs_context(fc); 228523bf1b6bSDavid Howells kfree(ctx); 228623bf1b6bSDavid Howells } 228723bf1b6bSDavid Howells 228823bf1b6bSDavid Howells static const struct fs_context_operations rdt_fs_context_ops = { 228923bf1b6bSDavid Howells .free = rdt_fs_context_free, 229023bf1b6bSDavid Howells .parse_param = rdt_parse_param, 229123bf1b6bSDavid Howells .get_tree = rdt_get_tree, 229223bf1b6bSDavid Howells }; 229323bf1b6bSDavid Howells 229423bf1b6bSDavid Howells static int rdt_init_fs_context(struct fs_context *fc) 229523bf1b6bSDavid Howells { 229623bf1b6bSDavid Howells struct rdt_fs_context *ctx; 229723bf1b6bSDavid Howells 229823bf1b6bSDavid Howells ctx = kzalloc(sizeof(struct rdt_fs_context), GFP_KERNEL); 229923bf1b6bSDavid Howells if (!ctx) 230023bf1b6bSDavid Howells return -ENOMEM; 230123bf1b6bSDavid Howells 230223bf1b6bSDavid Howells ctx->kfc.root = rdt_root; 230323bf1b6bSDavid Howells ctx->kfc.magic = RDTGROUP_SUPER_MAGIC; 230423bf1b6bSDavid Howells fc->fs_private = &ctx->kfc; 230523bf1b6bSDavid Howells fc->ops = &rdt_fs_context_ops; 230623bf1b6bSDavid Howells put_user_ns(fc->user_ns); 230723bf1b6bSDavid Howells fc->user_ns = get_user_ns(&init_user_ns); 230823bf1b6bSDavid Howells fc->global = true; 230923bf1b6bSDavid Howells return 0; 2310fa7d9493SBabu Moger } 2311fa7d9493SBabu Moger 2312fa7d9493SBabu Moger static int reset_all_ctrls(struct rdt_resource *r) 2313fa7d9493SBabu Moger { 231463c8b123SJames Morse struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r); 2315792e0f6fSJames Morse struct rdt_hw_domain *hw_dom; 2316fa7d9493SBabu Moger struct msr_param msr_param; 2317fa7d9493SBabu Moger cpumask_var_t cpu_mask; 2318fa7d9493SBabu Moger struct rdt_domain *d; 2319fa7d9493SBabu Moger int i, cpu; 2320fa7d9493SBabu Moger 2321fa7d9493SBabu Moger if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL)) 2322fa7d9493SBabu Moger return -ENOMEM; 2323fa7d9493SBabu Moger 2324fa7d9493SBabu Moger msr_param.res = r; 2325fa7d9493SBabu Moger msr_param.low = 0; 232663c8b123SJames Morse msr_param.high = hw_res->num_closid; 2327fa7d9493SBabu Moger 2328fa7d9493SBabu Moger /* 2329fa7d9493SBabu Moger * Disable resource control for this resource by setting all 2330fa7d9493SBabu Moger * CBMs in all domains to the maximum mask value. Pick one CPU 2331fa7d9493SBabu Moger * from each domain to update the MSRs below. 2332fa7d9493SBabu Moger */ 2333fa7d9493SBabu Moger list_for_each_entry(d, &r->domains, list) { 2334792e0f6fSJames Morse hw_dom = resctrl_to_arch_dom(d); 2335fa7d9493SBabu Moger cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask); 2336fa7d9493SBabu Moger 233763c8b123SJames Morse for (i = 0; i < hw_res->num_closid; i++) 2338792e0f6fSJames Morse hw_dom->ctrl_val[i] = r->default_ctrl; 2339fa7d9493SBabu Moger } 2340fa7d9493SBabu Moger cpu = get_cpu(); 2341fa7d9493SBabu Moger /* Update CBM on this cpu if it's in cpu_mask. */ 2342fa7d9493SBabu Moger if (cpumask_test_cpu(cpu, cpu_mask)) 2343fa7d9493SBabu Moger rdt_ctrl_update(&msr_param); 2344fa7d9493SBabu Moger /* Update CBM on all other cpus in cpu_mask. */ 2345fa7d9493SBabu Moger smp_call_function_many(cpu_mask, rdt_ctrl_update, &msr_param, 1); 2346fa7d9493SBabu Moger put_cpu(); 2347fa7d9493SBabu Moger 2348fa7d9493SBabu Moger free_cpumask_var(cpu_mask); 2349fa7d9493SBabu Moger 2350fa7d9493SBabu Moger return 0; 2351fa7d9493SBabu Moger } 2352fa7d9493SBabu Moger 2353fa7d9493SBabu Moger /* 2354fa7d9493SBabu Moger * Move tasks from one to the other group. If @from is NULL, then all tasks 2355fa7d9493SBabu Moger * in the systems are moved unconditionally (used for teardown). 2356fa7d9493SBabu Moger * 2357fa7d9493SBabu Moger * If @mask is not NULL the cpus on which moved tasks are running are set 2358fa7d9493SBabu Moger * in that mask so the update smp function call is restricted to affected 2359fa7d9493SBabu Moger * cpus. 2360fa7d9493SBabu Moger */ 2361fa7d9493SBabu Moger static void rdt_move_group_tasks(struct rdtgroup *from, struct rdtgroup *to, 2362fa7d9493SBabu Moger struct cpumask *mask) 2363fa7d9493SBabu Moger { 2364fa7d9493SBabu Moger struct task_struct *p, *t; 2365fa7d9493SBabu Moger 2366fa7d9493SBabu Moger read_lock(&tasklist_lock); 2367fa7d9493SBabu Moger for_each_process_thread(p, t) { 2368fa7d9493SBabu Moger if (!from || is_closid_match(t, from) || 2369fa7d9493SBabu Moger is_rmid_match(t, from)) { 23706d3b47ddSValentin Schneider WRITE_ONCE(t->closid, to->closid); 23716d3b47ddSValentin Schneider WRITE_ONCE(t->rmid, to->mon.rmid); 2372fa7d9493SBabu Moger 2373fa7d9493SBabu Moger /* 2374e0ad6dc8SReinette Chatre * If the task is on a CPU, set the CPU in the mask. 2375e0ad6dc8SReinette Chatre * The detection is inaccurate as tasks might move or 2376e0ad6dc8SReinette Chatre * schedule before the smp function call takes place. 2377e0ad6dc8SReinette Chatre * In such a case the function call is pointless, but 2378fa7d9493SBabu Moger * there is no other side effect. 2379fa7d9493SBabu Moger */ 2380e0ad6dc8SReinette Chatre if (IS_ENABLED(CONFIG_SMP) && mask && task_curr(t)) 2381fa7d9493SBabu Moger cpumask_set_cpu(task_cpu(t), mask); 2382fa7d9493SBabu Moger } 2383fa7d9493SBabu Moger } 2384fa7d9493SBabu Moger read_unlock(&tasklist_lock); 2385fa7d9493SBabu Moger } 2386fa7d9493SBabu Moger 2387fa7d9493SBabu Moger static void free_all_child_rdtgrp(struct rdtgroup *rdtgrp) 2388fa7d9493SBabu Moger { 2389fa7d9493SBabu Moger struct rdtgroup *sentry, *stmp; 2390fa7d9493SBabu Moger struct list_head *head; 2391fa7d9493SBabu Moger 2392fa7d9493SBabu Moger head = &rdtgrp->mon.crdtgrp_list; 2393fa7d9493SBabu Moger list_for_each_entry_safe(sentry, stmp, head, mon.crdtgrp_list) { 2394fa7d9493SBabu Moger free_rmid(sentry->mon.rmid); 2395fa7d9493SBabu Moger list_del(&sentry->mon.crdtgrp_list); 2396b8511cccSXiaochen Shen 2397b8511cccSXiaochen Shen if (atomic_read(&sentry->waitcount) != 0) 2398b8511cccSXiaochen Shen sentry->flags = RDT_DELETED; 2399b8511cccSXiaochen Shen else 240075899924SXiaochen Shen rdtgroup_remove(sentry); 2401fa7d9493SBabu Moger } 2402fa7d9493SBabu Moger } 2403fa7d9493SBabu Moger 2404fa7d9493SBabu Moger /* 2405fa7d9493SBabu Moger * Forcibly remove all of subdirectories under root. 2406fa7d9493SBabu Moger */ 2407fa7d9493SBabu Moger static void rmdir_all_sub(void) 2408fa7d9493SBabu Moger { 2409fa7d9493SBabu Moger struct rdtgroup *rdtgrp, *tmp; 2410fa7d9493SBabu Moger 2411fa7d9493SBabu Moger /* Move all tasks to the default resource group */ 2412fa7d9493SBabu Moger rdt_move_group_tasks(NULL, &rdtgroup_default, NULL); 2413fa7d9493SBabu Moger 2414fa7d9493SBabu Moger list_for_each_entry_safe(rdtgrp, tmp, &rdt_all_groups, rdtgroup_list) { 2415fa7d9493SBabu Moger /* Free any child rmids */ 2416fa7d9493SBabu Moger free_all_child_rdtgrp(rdtgrp); 2417fa7d9493SBabu Moger 2418fa7d9493SBabu Moger /* Remove each rdtgroup other than root */ 2419fa7d9493SBabu Moger if (rdtgrp == &rdtgroup_default) 2420fa7d9493SBabu Moger continue; 2421fa7d9493SBabu Moger 2422fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2423fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2424fa7d9493SBabu Moger rdtgroup_pseudo_lock_remove(rdtgrp); 2425fa7d9493SBabu Moger 2426fa7d9493SBabu Moger /* 2427fa7d9493SBabu Moger * Give any CPUs back to the default group. We cannot copy 2428fa7d9493SBabu Moger * cpu_online_mask because a CPU might have executed the 2429fa7d9493SBabu Moger * offline callback already, but is still marked online. 2430fa7d9493SBabu Moger */ 2431fa7d9493SBabu Moger cpumask_or(&rdtgroup_default.cpu_mask, 2432fa7d9493SBabu Moger &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 2433fa7d9493SBabu Moger 2434fa7d9493SBabu Moger free_rmid(rdtgrp->mon.rmid); 2435fa7d9493SBabu Moger 2436fa7d9493SBabu Moger kernfs_remove(rdtgrp->kn); 2437fa7d9493SBabu Moger list_del(&rdtgrp->rdtgroup_list); 2438b8511cccSXiaochen Shen 2439b8511cccSXiaochen Shen if (atomic_read(&rdtgrp->waitcount) != 0) 2440b8511cccSXiaochen Shen rdtgrp->flags = RDT_DELETED; 2441b8511cccSXiaochen Shen else 244275899924SXiaochen Shen rdtgroup_remove(rdtgrp); 2443fa7d9493SBabu Moger } 2444fa7d9493SBabu Moger /* Notify online CPUs to update per cpu storage and PQR_ASSOC MSR */ 2445fa7d9493SBabu Moger update_closid_rmid(cpu_online_mask, &rdtgroup_default); 2446fa7d9493SBabu Moger 2447fa7d9493SBabu Moger kernfs_remove(kn_info); 2448fa7d9493SBabu Moger kernfs_remove(kn_mongrp); 2449fa7d9493SBabu Moger kernfs_remove(kn_mondata); 2450fa7d9493SBabu Moger } 2451fa7d9493SBabu Moger 2452fa7d9493SBabu Moger static void rdt_kill_sb(struct super_block *sb) 2453fa7d9493SBabu Moger { 2454fa7d9493SBabu Moger struct rdt_resource *r; 2455fa7d9493SBabu Moger 2456fa7d9493SBabu Moger cpus_read_lock(); 2457fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 2458fa7d9493SBabu Moger 2459fa7d9493SBabu Moger set_mba_sc(false); 2460fa7d9493SBabu Moger 2461fa7d9493SBabu Moger /*Put everything back to default values. */ 2462fa7d9493SBabu Moger for_each_alloc_enabled_rdt_resource(r) 2463fa7d9493SBabu Moger reset_all_ctrls(r); 2464fa7d9493SBabu Moger cdp_disable_all(); 2465fa7d9493SBabu Moger rmdir_all_sub(); 2466fa7d9493SBabu Moger rdt_pseudo_lock_release(); 2467fa7d9493SBabu Moger rdtgroup_default.mode = RDT_MODE_SHAREABLE; 2468*cdb9ebc9SJames Morse schemata_list_destroy(); 2469fa7d9493SBabu Moger static_branch_disable_cpuslocked(&rdt_alloc_enable_key); 2470fa7d9493SBabu Moger static_branch_disable_cpuslocked(&rdt_mon_enable_key); 2471fa7d9493SBabu Moger static_branch_disable_cpuslocked(&rdt_enable_key); 2472fa7d9493SBabu Moger kernfs_kill_sb(sb); 2473fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 2474fa7d9493SBabu Moger cpus_read_unlock(); 2475fa7d9493SBabu Moger } 2476fa7d9493SBabu Moger 2477fa7d9493SBabu Moger static struct file_system_type rdt_fs_type = { 2478fa7d9493SBabu Moger .name = "resctrl", 247923bf1b6bSDavid Howells .init_fs_context = rdt_init_fs_context, 2480d7167b14SAl Viro .parameters = rdt_fs_parameters, 2481fa7d9493SBabu Moger .kill_sb = rdt_kill_sb, 2482fa7d9493SBabu Moger }; 2483fa7d9493SBabu Moger 2484fa7d9493SBabu Moger static int mon_addfile(struct kernfs_node *parent_kn, const char *name, 2485fa7d9493SBabu Moger void *priv) 2486fa7d9493SBabu Moger { 2487fa7d9493SBabu Moger struct kernfs_node *kn; 2488fa7d9493SBabu Moger int ret = 0; 2489fa7d9493SBabu Moger 2490fa7d9493SBabu Moger kn = __kernfs_create_file(parent_kn, name, 0444, 2491fa7d9493SBabu Moger GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 0, 2492fa7d9493SBabu Moger &kf_mondata_ops, priv, NULL, NULL); 2493fa7d9493SBabu Moger if (IS_ERR(kn)) 2494fa7d9493SBabu Moger return PTR_ERR(kn); 2495fa7d9493SBabu Moger 2496fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 2497fa7d9493SBabu Moger if (ret) { 2498fa7d9493SBabu Moger kernfs_remove(kn); 2499fa7d9493SBabu Moger return ret; 2500fa7d9493SBabu Moger } 2501fa7d9493SBabu Moger 2502fa7d9493SBabu Moger return ret; 2503fa7d9493SBabu Moger } 2504fa7d9493SBabu Moger 2505fa7d9493SBabu Moger /* 2506fa7d9493SBabu Moger * Remove all subdirectories of mon_data of ctrl_mon groups 2507fa7d9493SBabu Moger * and monitor groups with given domain id. 2508fa7d9493SBabu Moger */ 2509fa7d9493SBabu Moger void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, unsigned int dom_id) 2510fa7d9493SBabu Moger { 2511fa7d9493SBabu Moger struct rdtgroup *prgrp, *crgrp; 2512fa7d9493SBabu Moger char name[32]; 2513fa7d9493SBabu Moger 2514fa7d9493SBabu Moger if (!r->mon_enabled) 2515fa7d9493SBabu Moger return; 2516fa7d9493SBabu Moger 2517fa7d9493SBabu Moger list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 2518fa7d9493SBabu Moger sprintf(name, "mon_%s_%02d", r->name, dom_id); 2519fa7d9493SBabu Moger kernfs_remove_by_name(prgrp->mon.mon_data_kn, name); 2520fa7d9493SBabu Moger 2521fa7d9493SBabu Moger list_for_each_entry(crgrp, &prgrp->mon.crdtgrp_list, mon.crdtgrp_list) 2522fa7d9493SBabu Moger kernfs_remove_by_name(crgrp->mon.mon_data_kn, name); 2523fa7d9493SBabu Moger } 2524fa7d9493SBabu Moger } 2525fa7d9493SBabu Moger 2526fa7d9493SBabu Moger static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, 2527fa7d9493SBabu Moger struct rdt_domain *d, 2528fa7d9493SBabu Moger struct rdt_resource *r, struct rdtgroup *prgrp) 2529fa7d9493SBabu Moger { 2530fa7d9493SBabu Moger union mon_data_bits priv; 2531fa7d9493SBabu Moger struct kernfs_node *kn; 2532fa7d9493SBabu Moger struct mon_evt *mevt; 2533fa7d9493SBabu Moger struct rmid_read rr; 2534fa7d9493SBabu Moger char name[32]; 2535fa7d9493SBabu Moger int ret; 2536fa7d9493SBabu Moger 2537fa7d9493SBabu Moger sprintf(name, "mon_%s_%02d", r->name, d->id); 2538fa7d9493SBabu Moger /* create the directory */ 2539fa7d9493SBabu Moger kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 2540fa7d9493SBabu Moger if (IS_ERR(kn)) 2541fa7d9493SBabu Moger return PTR_ERR(kn); 2542fa7d9493SBabu Moger 2543fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 2544fa7d9493SBabu Moger if (ret) 2545fa7d9493SBabu Moger goto out_destroy; 2546fa7d9493SBabu Moger 2547fa7d9493SBabu Moger if (WARN_ON(list_empty(&r->evt_list))) { 2548fa7d9493SBabu Moger ret = -EPERM; 2549fa7d9493SBabu Moger goto out_destroy; 2550fa7d9493SBabu Moger } 2551fa7d9493SBabu Moger 2552fa7d9493SBabu Moger priv.u.rid = r->rid; 2553fa7d9493SBabu Moger priv.u.domid = d->id; 2554fa7d9493SBabu Moger list_for_each_entry(mevt, &r->evt_list, list) { 2555fa7d9493SBabu Moger priv.u.evtid = mevt->evtid; 2556fa7d9493SBabu Moger ret = mon_addfile(kn, mevt->name, priv.priv); 2557fa7d9493SBabu Moger if (ret) 2558fa7d9493SBabu Moger goto out_destroy; 2559fa7d9493SBabu Moger 2560fa7d9493SBabu Moger if (is_mbm_event(mevt->evtid)) 256146637d45SReinette Chatre mon_event_read(&rr, r, d, prgrp, mevt->evtid, true); 2562fa7d9493SBabu Moger } 2563fa7d9493SBabu Moger kernfs_activate(kn); 2564fa7d9493SBabu Moger return 0; 2565fa7d9493SBabu Moger 2566fa7d9493SBabu Moger out_destroy: 2567fa7d9493SBabu Moger kernfs_remove(kn); 2568fa7d9493SBabu Moger return ret; 2569fa7d9493SBabu Moger } 2570fa7d9493SBabu Moger 2571fa7d9493SBabu Moger /* 2572fa7d9493SBabu Moger * Add all subdirectories of mon_data for "ctrl_mon" groups 2573fa7d9493SBabu Moger * and "monitor" groups with given domain id. 2574fa7d9493SBabu Moger */ 2575fa7d9493SBabu Moger void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 2576fa7d9493SBabu Moger struct rdt_domain *d) 2577fa7d9493SBabu Moger { 2578fa7d9493SBabu Moger struct kernfs_node *parent_kn; 2579fa7d9493SBabu Moger struct rdtgroup *prgrp, *crgrp; 2580fa7d9493SBabu Moger struct list_head *head; 2581fa7d9493SBabu Moger 2582fa7d9493SBabu Moger if (!r->mon_enabled) 2583fa7d9493SBabu Moger return; 2584fa7d9493SBabu Moger 2585fa7d9493SBabu Moger list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 2586fa7d9493SBabu Moger parent_kn = prgrp->mon.mon_data_kn; 2587fa7d9493SBabu Moger mkdir_mondata_subdir(parent_kn, d, r, prgrp); 2588fa7d9493SBabu Moger 2589fa7d9493SBabu Moger head = &prgrp->mon.crdtgrp_list; 2590fa7d9493SBabu Moger list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 2591fa7d9493SBabu Moger parent_kn = crgrp->mon.mon_data_kn; 2592fa7d9493SBabu Moger mkdir_mondata_subdir(parent_kn, d, r, crgrp); 2593fa7d9493SBabu Moger } 2594fa7d9493SBabu Moger } 2595fa7d9493SBabu Moger } 2596fa7d9493SBabu Moger 2597fa7d9493SBabu Moger static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, 2598fa7d9493SBabu Moger struct rdt_resource *r, 2599fa7d9493SBabu Moger struct rdtgroup *prgrp) 2600fa7d9493SBabu Moger { 2601fa7d9493SBabu Moger struct rdt_domain *dom; 2602fa7d9493SBabu Moger int ret; 2603fa7d9493SBabu Moger 2604fa7d9493SBabu Moger list_for_each_entry(dom, &r->domains, list) { 2605fa7d9493SBabu Moger ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp); 2606fa7d9493SBabu Moger if (ret) 2607fa7d9493SBabu Moger return ret; 2608fa7d9493SBabu Moger } 2609fa7d9493SBabu Moger 2610fa7d9493SBabu Moger return 0; 2611fa7d9493SBabu Moger } 2612fa7d9493SBabu Moger 2613fa7d9493SBabu Moger /* 2614fa7d9493SBabu Moger * This creates a directory mon_data which contains the monitored data. 2615fa7d9493SBabu Moger * 2616163b0991SIngo Molnar * mon_data has one directory for each domain which are named 2617fa7d9493SBabu Moger * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data 2618fa7d9493SBabu Moger * with L3 domain looks as below: 2619fa7d9493SBabu Moger * ./mon_data: 2620fa7d9493SBabu Moger * mon_L3_00 2621fa7d9493SBabu Moger * mon_L3_01 2622fa7d9493SBabu Moger * mon_L3_02 2623fa7d9493SBabu Moger * ... 2624fa7d9493SBabu Moger * 2625fa7d9493SBabu Moger * Each domain directory has one file per event: 2626fa7d9493SBabu Moger * ./mon_L3_00/: 2627fa7d9493SBabu Moger * llc_occupancy 2628fa7d9493SBabu Moger * 2629fa7d9493SBabu Moger */ 2630fa7d9493SBabu Moger static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2631fa7d9493SBabu Moger struct rdtgroup *prgrp, 2632fa7d9493SBabu Moger struct kernfs_node **dest_kn) 2633fa7d9493SBabu Moger { 2634fa7d9493SBabu Moger struct rdt_resource *r; 2635fa7d9493SBabu Moger struct kernfs_node *kn; 2636fa7d9493SBabu Moger int ret; 2637fa7d9493SBabu Moger 2638fa7d9493SBabu Moger /* 2639fa7d9493SBabu Moger * Create the mon_data directory first. 2640fa7d9493SBabu Moger */ 2641334b0f4eSXiaochen Shen ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn); 2642fa7d9493SBabu Moger if (ret) 2643fa7d9493SBabu Moger return ret; 2644fa7d9493SBabu Moger 2645fa7d9493SBabu Moger if (dest_kn) 2646fa7d9493SBabu Moger *dest_kn = kn; 2647fa7d9493SBabu Moger 2648fa7d9493SBabu Moger /* 2649fa7d9493SBabu Moger * Create the subdirectories for each domain. Note that all events 2650fa7d9493SBabu Moger * in a domain like L3 are grouped into a resource whose domain is L3 2651fa7d9493SBabu Moger */ 2652fa7d9493SBabu Moger for_each_mon_enabled_rdt_resource(r) { 2653fa7d9493SBabu Moger ret = mkdir_mondata_subdir_alldom(kn, r, prgrp); 2654fa7d9493SBabu Moger if (ret) 2655fa7d9493SBabu Moger goto out_destroy; 2656fa7d9493SBabu Moger } 2657fa7d9493SBabu Moger 2658fa7d9493SBabu Moger return 0; 2659fa7d9493SBabu Moger 2660fa7d9493SBabu Moger out_destroy: 2661fa7d9493SBabu Moger kernfs_remove(kn); 2662fa7d9493SBabu Moger return ret; 2663fa7d9493SBabu Moger } 2664fa7d9493SBabu Moger 2665fa7d9493SBabu Moger /** 2666fa7d9493SBabu Moger * cbm_ensure_valid - Enforce validity on provided CBM 2667fa7d9493SBabu Moger * @_val: Candidate CBM 2668fa7d9493SBabu Moger * @r: RDT resource to which the CBM belongs 2669fa7d9493SBabu Moger * 2670fa7d9493SBabu Moger * The provided CBM represents all cache portions available for use. This 2671fa7d9493SBabu Moger * may be represented by a bitmap that does not consist of contiguous ones 2672fa7d9493SBabu Moger * and thus be an invalid CBM. 2673fa7d9493SBabu Moger * Here the provided CBM is forced to be a valid CBM by only considering 2674fa7d9493SBabu Moger * the first set of contiguous bits as valid and clearing all bits. 2675fa7d9493SBabu Moger * The intention here is to provide a valid default CBM with which a new 2676fa7d9493SBabu Moger * resource group is initialized. The user can follow this with a 2677fa7d9493SBabu Moger * modification to the CBM if the default does not satisfy the 2678fa7d9493SBabu Moger * requirements. 2679fa7d9493SBabu Moger */ 26802ef085bdSReinette Chatre static u32 cbm_ensure_valid(u32 _val, struct rdt_resource *r) 2681fa7d9493SBabu Moger { 2682fa7d9493SBabu Moger unsigned int cbm_len = r->cache.cbm_len; 2683fa7d9493SBabu Moger unsigned long first_bit, zero_bit; 26842ef085bdSReinette Chatre unsigned long val = _val; 2685fa7d9493SBabu Moger 26862ef085bdSReinette Chatre if (!val) 26872ef085bdSReinette Chatre return 0; 2688fa7d9493SBabu Moger 268932f010deSReinette Chatre first_bit = find_first_bit(&val, cbm_len); 269032f010deSReinette Chatre zero_bit = find_next_zero_bit(&val, cbm_len, first_bit); 2691fa7d9493SBabu Moger 2692fa7d9493SBabu Moger /* Clear any remaining bits to ensure contiguous region */ 269332f010deSReinette Chatre bitmap_clear(&val, zero_bit, cbm_len - zero_bit); 26942ef085bdSReinette Chatre return (u32)val; 2695fa7d9493SBabu Moger } 2696fa7d9493SBabu Moger 26977390619aSXiaochen Shen /* 26987390619aSXiaochen Shen * Initialize cache resources per RDT domain 2699fa7d9493SBabu Moger * 27007390619aSXiaochen Shen * Set the RDT domain up to start off with all usable allocations. That is, 27017390619aSXiaochen Shen * all shareable and unused bits. All-zero CBM is invalid. 2702fa7d9493SBabu Moger */ 27037390619aSXiaochen Shen static int __init_one_rdt_domain(struct rdt_domain *d, struct rdt_resource *r, 27047390619aSXiaochen Shen u32 closid) 2705fa7d9493SBabu Moger { 2706fa7d9493SBabu Moger struct rdt_resource *r_cdp = NULL; 2707fa7d9493SBabu Moger struct rdt_domain *d_cdp = NULL; 2708fa7d9493SBabu Moger u32 used_b = 0, unused_b = 0; 2709fa7d9493SBabu Moger unsigned long tmp_cbm; 2710fa7d9493SBabu Moger enum rdtgrp_mode mode; 2711fa7d9493SBabu Moger u32 peer_ctl, *ctrl; 27127390619aSXiaochen Shen int i; 2713fa7d9493SBabu Moger 2714fa7d9493SBabu Moger rdt_cdp_peer_get(r, d, &r_cdp, &d_cdp); 2715fa7d9493SBabu Moger d->have_new_ctrl = false; 2716fa7d9493SBabu Moger d->new_ctrl = r->cache.shareable_bits; 2717fa7d9493SBabu Moger used_b = r->cache.shareable_bits; 2718792e0f6fSJames Morse ctrl = resctrl_to_arch_dom(d)->ctrl_val; 2719fa7d9493SBabu Moger for (i = 0; i < closids_supported(); i++, ctrl++) { 2720fa7d9493SBabu Moger if (closid_allocated(i) && i != closid) { 2721fa7d9493SBabu Moger mode = rdtgroup_mode_by_closid(i); 2722fa7d9493SBabu Moger if (mode == RDT_MODE_PSEUDO_LOCKSETUP) 272387d3aa28SJames Morse /* 272487d3aa28SJames Morse * ctrl values for locksetup aren't relevant 272587d3aa28SJames Morse * until the schemata is written, and the mode 272687d3aa28SJames Morse * becomes RDT_MODE_PSEUDO_LOCKED. 272787d3aa28SJames Morse */ 272887d3aa28SJames Morse continue; 2729fa7d9493SBabu Moger /* 27307390619aSXiaochen Shen * If CDP is active include peer domain's 27317390619aSXiaochen Shen * usage to ensure there is no overlap 27327390619aSXiaochen Shen * with an exclusive group. 2733fa7d9493SBabu Moger */ 2734fa7d9493SBabu Moger if (d_cdp) 2735792e0f6fSJames Morse peer_ctl = resctrl_to_arch_dom(d_cdp)->ctrl_val[i]; 2736fa7d9493SBabu Moger else 2737fa7d9493SBabu Moger peer_ctl = 0; 2738fa7d9493SBabu Moger used_b |= *ctrl | peer_ctl; 2739fa7d9493SBabu Moger if (mode == RDT_MODE_SHAREABLE) 2740fa7d9493SBabu Moger d->new_ctrl |= *ctrl | peer_ctl; 2741fa7d9493SBabu Moger } 2742fa7d9493SBabu Moger } 2743fa7d9493SBabu Moger if (d->plr && d->plr->cbm > 0) 2744fa7d9493SBabu Moger used_b |= d->plr->cbm; 2745fa7d9493SBabu Moger unused_b = used_b ^ (BIT_MASK(r->cache.cbm_len) - 1); 2746fa7d9493SBabu Moger unused_b &= BIT_MASK(r->cache.cbm_len) - 1; 2747fa7d9493SBabu Moger d->new_ctrl |= unused_b; 2748fa7d9493SBabu Moger /* 2749fa7d9493SBabu Moger * Force the initial CBM to be valid, user can 2750fa7d9493SBabu Moger * modify the CBM based on system availability. 2751fa7d9493SBabu Moger */ 27522ef085bdSReinette Chatre d->new_ctrl = cbm_ensure_valid(d->new_ctrl, r); 2753fa7d9493SBabu Moger /* 27547390619aSXiaochen Shen * Assign the u32 CBM to an unsigned long to ensure that 27557390619aSXiaochen Shen * bitmap_weight() does not access out-of-bound memory. 2756fa7d9493SBabu Moger */ 2757fa7d9493SBabu Moger tmp_cbm = d->new_ctrl; 27587390619aSXiaochen Shen if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) { 27597390619aSXiaochen Shen rdt_last_cmd_printf("No space on %s:%d\n", r->name, d->id); 2760fa7d9493SBabu Moger return -ENOSPC; 2761fa7d9493SBabu Moger } 2762fa7d9493SBabu Moger d->have_new_ctrl = true; 27637390619aSXiaochen Shen 27647390619aSXiaochen Shen return 0; 27657390619aSXiaochen Shen } 27667390619aSXiaochen Shen 276747820e73SXiaochen Shen /* 276847820e73SXiaochen Shen * Initialize cache resources with default values. 27697390619aSXiaochen Shen * 27707390619aSXiaochen Shen * A new RDT group is being created on an allocation capable (CAT) 27717390619aSXiaochen Shen * supporting system. Set this group up to start off with all usable 27727390619aSXiaochen Shen * allocations. 27737390619aSXiaochen Shen * 27747390619aSXiaochen Shen * If there are no more shareable bits available on any domain then 27757390619aSXiaochen Shen * the entire allocation will fail. 27767390619aSXiaochen Shen */ 277747820e73SXiaochen Shen static int rdtgroup_init_cat(struct rdt_resource *r, u32 closid) 27787390619aSXiaochen Shen { 27797390619aSXiaochen Shen struct rdt_domain *d; 27807390619aSXiaochen Shen int ret; 27817390619aSXiaochen Shen 27827390619aSXiaochen Shen list_for_each_entry(d, &r->domains, list) { 278347820e73SXiaochen Shen ret = __init_one_rdt_domain(d, r, closid); 27847390619aSXiaochen Shen if (ret < 0) 27857390619aSXiaochen Shen return ret; 2786fa7d9493SBabu Moger } 278747820e73SXiaochen Shen 278847820e73SXiaochen Shen return 0; 2789fa7d9493SBabu Moger } 2790fa7d9493SBabu Moger 279147820e73SXiaochen Shen /* Initialize MBA resource with default values. */ 279247820e73SXiaochen Shen static void rdtgroup_init_mba(struct rdt_resource *r) 279347820e73SXiaochen Shen { 279447820e73SXiaochen Shen struct rdt_domain *d; 279547820e73SXiaochen Shen 279647820e73SXiaochen Shen list_for_each_entry(d, &r->domains, list) { 279747820e73SXiaochen Shen d->new_ctrl = is_mba_sc(r) ? MBA_MAX_MBPS : r->default_ctrl; 279847820e73SXiaochen Shen d->have_new_ctrl = true; 279947820e73SXiaochen Shen } 280047820e73SXiaochen Shen } 280147820e73SXiaochen Shen 280247820e73SXiaochen Shen /* Initialize the RDT group's allocations. */ 280347820e73SXiaochen Shen static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp) 280447820e73SXiaochen Shen { 280547820e73SXiaochen Shen struct rdt_resource *r; 280647820e73SXiaochen Shen int ret; 280747820e73SXiaochen Shen 2808fa7d9493SBabu Moger for_each_alloc_enabled_rdt_resource(r) { 280947820e73SXiaochen Shen if (r->rid == RDT_RESOURCE_MBA) { 281047820e73SXiaochen Shen rdtgroup_init_mba(r); 281147820e73SXiaochen Shen } else { 281247820e73SXiaochen Shen ret = rdtgroup_init_cat(r, rdtgrp->closid); 281347820e73SXiaochen Shen if (ret < 0) 281447820e73SXiaochen Shen return ret; 281547820e73SXiaochen Shen } 281647820e73SXiaochen Shen 2817fa7d9493SBabu Moger ret = update_domains(r, rdtgrp->closid); 2818fa7d9493SBabu Moger if (ret < 0) { 2819723f1a0dSBabu Moger rdt_last_cmd_puts("Failed to initialize allocations\n"); 2820fa7d9493SBabu Moger return ret; 2821fa7d9493SBabu Moger } 282247820e73SXiaochen Shen 2823fa7d9493SBabu Moger } 2824fa7d9493SBabu Moger 282540fba00fSXiaochen Shen rdtgrp->mode = RDT_MODE_SHAREABLE; 282640fba00fSXiaochen Shen 2827fa7d9493SBabu Moger return 0; 2828fa7d9493SBabu Moger } 2829fa7d9493SBabu Moger 2830fa7d9493SBabu Moger static int mkdir_rdt_prepare(struct kernfs_node *parent_kn, 2831fa7d9493SBabu Moger const char *name, umode_t mode, 2832fa7d9493SBabu Moger enum rdt_group_type rtype, struct rdtgroup **r) 2833fa7d9493SBabu Moger { 2834fa7d9493SBabu Moger struct rdtgroup *prdtgrp, *rdtgrp; 2835fa7d9493SBabu Moger struct kernfs_node *kn; 2836fa7d9493SBabu Moger uint files = 0; 2837fa7d9493SBabu Moger int ret; 2838fa7d9493SBabu Moger 2839334b0f4eSXiaochen Shen prdtgrp = rdtgroup_kn_lock_live(parent_kn); 2840fa7d9493SBabu Moger if (!prdtgrp) { 2841fa7d9493SBabu Moger ret = -ENODEV; 2842fa7d9493SBabu Moger goto out_unlock; 2843fa7d9493SBabu Moger } 2844fa7d9493SBabu Moger 2845fa7d9493SBabu Moger if (rtype == RDTMON_GROUP && 2846fa7d9493SBabu Moger (prdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2847fa7d9493SBabu Moger prdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)) { 2848fa7d9493SBabu Moger ret = -EINVAL; 2849723f1a0dSBabu Moger rdt_last_cmd_puts("Pseudo-locking in progress\n"); 2850fa7d9493SBabu Moger goto out_unlock; 2851fa7d9493SBabu Moger } 2852fa7d9493SBabu Moger 2853fa7d9493SBabu Moger /* allocate the rdtgroup. */ 2854fa7d9493SBabu Moger rdtgrp = kzalloc(sizeof(*rdtgrp), GFP_KERNEL); 2855fa7d9493SBabu Moger if (!rdtgrp) { 2856fa7d9493SBabu Moger ret = -ENOSPC; 2857723f1a0dSBabu Moger rdt_last_cmd_puts("Kernel out of memory\n"); 2858fa7d9493SBabu Moger goto out_unlock; 2859fa7d9493SBabu Moger } 2860fa7d9493SBabu Moger *r = rdtgrp; 2861fa7d9493SBabu Moger rdtgrp->mon.parent = prdtgrp; 2862fa7d9493SBabu Moger rdtgrp->type = rtype; 2863fa7d9493SBabu Moger INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list); 2864fa7d9493SBabu Moger 2865fa7d9493SBabu Moger /* kernfs creates the directory for rdtgrp */ 2866fa7d9493SBabu Moger kn = kernfs_create_dir(parent_kn, name, mode, rdtgrp); 2867fa7d9493SBabu Moger if (IS_ERR(kn)) { 2868fa7d9493SBabu Moger ret = PTR_ERR(kn); 2869fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs create error\n"); 2870fa7d9493SBabu Moger goto out_free_rgrp; 2871fa7d9493SBabu Moger } 2872fa7d9493SBabu Moger rdtgrp->kn = kn; 2873fa7d9493SBabu Moger 2874fa7d9493SBabu Moger /* 2875fa7d9493SBabu Moger * kernfs_remove() will drop the reference count on "kn" which 2876fa7d9493SBabu Moger * will free it. But we still need it to stick around for the 2877fd8d9db3SXiaochen Shen * rdtgroup_kn_unlock(kn) call. Take one extra reference here, 287875899924SXiaochen Shen * which will be dropped by kernfs_put() in rdtgroup_remove(). 2879fa7d9493SBabu Moger */ 2880fa7d9493SBabu Moger kernfs_get(kn); 2881fa7d9493SBabu Moger 2882fa7d9493SBabu Moger ret = rdtgroup_kn_set_ugid(kn); 2883fa7d9493SBabu Moger if (ret) { 2884fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs perm error\n"); 2885fa7d9493SBabu Moger goto out_destroy; 2886fa7d9493SBabu Moger } 2887fa7d9493SBabu Moger 2888fa7d9493SBabu Moger files = RFTYPE_BASE | BIT(RF_CTRLSHIFT + rtype); 2889fa7d9493SBabu Moger ret = rdtgroup_add_files(kn, files); 2890fa7d9493SBabu Moger if (ret) { 2891fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs fill error\n"); 2892fa7d9493SBabu Moger goto out_destroy; 2893fa7d9493SBabu Moger } 2894fa7d9493SBabu Moger 2895fa7d9493SBabu Moger if (rdt_mon_capable) { 2896fa7d9493SBabu Moger ret = alloc_rmid(); 2897fa7d9493SBabu Moger if (ret < 0) { 2898723f1a0dSBabu Moger rdt_last_cmd_puts("Out of RMIDs\n"); 2899fa7d9493SBabu Moger goto out_destroy; 2900fa7d9493SBabu Moger } 2901fa7d9493SBabu Moger rdtgrp->mon.rmid = ret; 2902fa7d9493SBabu Moger 2903fa7d9493SBabu Moger ret = mkdir_mondata_all(kn, rdtgrp, &rdtgrp->mon.mon_data_kn); 2904fa7d9493SBabu Moger if (ret) { 2905fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs subdir error\n"); 2906fa7d9493SBabu Moger goto out_idfree; 2907fa7d9493SBabu Moger } 2908fa7d9493SBabu Moger } 2909fa7d9493SBabu Moger kernfs_activate(kn); 2910fa7d9493SBabu Moger 2911fa7d9493SBabu Moger /* 2912334b0f4eSXiaochen Shen * The caller unlocks the parent_kn upon success. 2913fa7d9493SBabu Moger */ 2914fa7d9493SBabu Moger return 0; 2915fa7d9493SBabu Moger 2916fa7d9493SBabu Moger out_idfree: 2917fa7d9493SBabu Moger free_rmid(rdtgrp->mon.rmid); 2918fa7d9493SBabu Moger out_destroy: 291975899924SXiaochen Shen kernfs_put(rdtgrp->kn); 2920fa7d9493SBabu Moger kernfs_remove(rdtgrp->kn); 2921fa7d9493SBabu Moger out_free_rgrp: 2922fa7d9493SBabu Moger kfree(rdtgrp); 2923fa7d9493SBabu Moger out_unlock: 2924334b0f4eSXiaochen Shen rdtgroup_kn_unlock(parent_kn); 2925fa7d9493SBabu Moger return ret; 2926fa7d9493SBabu Moger } 2927fa7d9493SBabu Moger 2928fa7d9493SBabu Moger static void mkdir_rdt_prepare_clean(struct rdtgroup *rgrp) 2929fa7d9493SBabu Moger { 2930fa7d9493SBabu Moger kernfs_remove(rgrp->kn); 2931fa7d9493SBabu Moger free_rmid(rgrp->mon.rmid); 293275899924SXiaochen Shen rdtgroup_remove(rgrp); 2933fa7d9493SBabu Moger } 2934fa7d9493SBabu Moger 2935fa7d9493SBabu Moger /* 2936fa7d9493SBabu Moger * Create a monitor group under "mon_groups" directory of a control 2937fa7d9493SBabu Moger * and monitor group(ctrl_mon). This is a resource group 2938fa7d9493SBabu Moger * to monitor a subset of tasks and cpus in its parent ctrl_mon group. 2939fa7d9493SBabu Moger */ 2940fa7d9493SBabu Moger static int rdtgroup_mkdir_mon(struct kernfs_node *parent_kn, 294132ada3b9SXiaochen Shen const char *name, umode_t mode) 2942fa7d9493SBabu Moger { 2943fa7d9493SBabu Moger struct rdtgroup *rdtgrp, *prgrp; 2944fa7d9493SBabu Moger int ret; 2945fa7d9493SBabu Moger 294632ada3b9SXiaochen Shen ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTMON_GROUP, &rdtgrp); 2947fa7d9493SBabu Moger if (ret) 2948fa7d9493SBabu Moger return ret; 2949fa7d9493SBabu Moger 2950fa7d9493SBabu Moger prgrp = rdtgrp->mon.parent; 2951fa7d9493SBabu Moger rdtgrp->closid = prgrp->closid; 2952fa7d9493SBabu Moger 2953fa7d9493SBabu Moger /* 2954fa7d9493SBabu Moger * Add the rdtgrp to the list of rdtgrps the parent 2955fa7d9493SBabu Moger * ctrl_mon group has to track. 2956fa7d9493SBabu Moger */ 2957fa7d9493SBabu Moger list_add_tail(&rdtgrp->mon.crdtgrp_list, &prgrp->mon.crdtgrp_list); 2958fa7d9493SBabu Moger 2959334b0f4eSXiaochen Shen rdtgroup_kn_unlock(parent_kn); 2960fa7d9493SBabu Moger return ret; 2961fa7d9493SBabu Moger } 2962fa7d9493SBabu Moger 2963fa7d9493SBabu Moger /* 2964fa7d9493SBabu Moger * These are rdtgroups created under the root directory. Can be used 2965fa7d9493SBabu Moger * to allocate and monitor resources. 2966fa7d9493SBabu Moger */ 2967fa7d9493SBabu Moger static int rdtgroup_mkdir_ctrl_mon(struct kernfs_node *parent_kn, 2968fa7d9493SBabu Moger const char *name, umode_t mode) 2969fa7d9493SBabu Moger { 2970fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 2971fa7d9493SBabu Moger struct kernfs_node *kn; 2972fa7d9493SBabu Moger u32 closid; 2973fa7d9493SBabu Moger int ret; 2974fa7d9493SBabu Moger 297532ada3b9SXiaochen Shen ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTCTRL_GROUP, &rdtgrp); 2976fa7d9493SBabu Moger if (ret) 2977fa7d9493SBabu Moger return ret; 2978fa7d9493SBabu Moger 2979fa7d9493SBabu Moger kn = rdtgrp->kn; 2980fa7d9493SBabu Moger ret = closid_alloc(); 2981fa7d9493SBabu Moger if (ret < 0) { 2982723f1a0dSBabu Moger rdt_last_cmd_puts("Out of CLOSIDs\n"); 2983fa7d9493SBabu Moger goto out_common_fail; 2984fa7d9493SBabu Moger } 2985fa7d9493SBabu Moger closid = ret; 2986fa7d9493SBabu Moger ret = 0; 2987fa7d9493SBabu Moger 2988fa7d9493SBabu Moger rdtgrp->closid = closid; 2989fa7d9493SBabu Moger ret = rdtgroup_init_alloc(rdtgrp); 2990fa7d9493SBabu Moger if (ret < 0) 2991fa7d9493SBabu Moger goto out_id_free; 2992fa7d9493SBabu Moger 2993fa7d9493SBabu Moger list_add(&rdtgrp->rdtgroup_list, &rdt_all_groups); 2994fa7d9493SBabu Moger 2995fa7d9493SBabu Moger if (rdt_mon_capable) { 2996fa7d9493SBabu Moger /* 2997fa7d9493SBabu Moger * Create an empty mon_groups directory to hold the subset 2998fa7d9493SBabu Moger * of tasks and cpus to monitor. 2999fa7d9493SBabu Moger */ 3000334b0f4eSXiaochen Shen ret = mongroup_create_dir(kn, rdtgrp, "mon_groups", NULL); 3001fa7d9493SBabu Moger if (ret) { 3002fa7d9493SBabu Moger rdt_last_cmd_puts("kernfs subdir error\n"); 3003fa7d9493SBabu Moger goto out_del_list; 3004fa7d9493SBabu Moger } 3005fa7d9493SBabu Moger } 3006fa7d9493SBabu Moger 3007fa7d9493SBabu Moger goto out_unlock; 3008fa7d9493SBabu Moger 3009fa7d9493SBabu Moger out_del_list: 3010fa7d9493SBabu Moger list_del(&rdtgrp->rdtgroup_list); 3011fa7d9493SBabu Moger out_id_free: 3012fa7d9493SBabu Moger closid_free(closid); 3013fa7d9493SBabu Moger out_common_fail: 3014fa7d9493SBabu Moger mkdir_rdt_prepare_clean(rdtgrp); 3015fa7d9493SBabu Moger out_unlock: 3016334b0f4eSXiaochen Shen rdtgroup_kn_unlock(parent_kn); 3017fa7d9493SBabu Moger return ret; 3018fa7d9493SBabu Moger } 3019fa7d9493SBabu Moger 3020fa7d9493SBabu Moger /* 3021fa7d9493SBabu Moger * We allow creating mon groups only with in a directory called "mon_groups" 3022fa7d9493SBabu Moger * which is present in every ctrl_mon group. Check if this is a valid 3023fa7d9493SBabu Moger * "mon_groups" directory. 3024fa7d9493SBabu Moger * 3025fa7d9493SBabu Moger * 1. The directory should be named "mon_groups". 3026fa7d9493SBabu Moger * 2. The mon group itself should "not" be named "mon_groups". 3027fa7d9493SBabu Moger * This makes sure "mon_groups" directory always has a ctrl_mon group 3028fa7d9493SBabu Moger * as parent. 3029fa7d9493SBabu Moger */ 3030fa7d9493SBabu Moger static bool is_mon_groups(struct kernfs_node *kn, const char *name) 3031fa7d9493SBabu Moger { 3032fa7d9493SBabu Moger return (!strcmp(kn->name, "mon_groups") && 3033fa7d9493SBabu Moger strcmp(name, "mon_groups")); 3034fa7d9493SBabu Moger } 3035fa7d9493SBabu Moger 3036fa7d9493SBabu Moger static int rdtgroup_mkdir(struct kernfs_node *parent_kn, const char *name, 3037fa7d9493SBabu Moger umode_t mode) 3038fa7d9493SBabu Moger { 3039fa7d9493SBabu Moger /* Do not accept '\n' to avoid unparsable situation. */ 3040fa7d9493SBabu Moger if (strchr(name, '\n')) 3041fa7d9493SBabu Moger return -EINVAL; 3042fa7d9493SBabu Moger 3043fa7d9493SBabu Moger /* 3044fa7d9493SBabu Moger * If the parent directory is the root directory and RDT 3045fa7d9493SBabu Moger * allocation is supported, add a control and monitoring 3046fa7d9493SBabu Moger * subdirectory 3047fa7d9493SBabu Moger */ 3048fa7d9493SBabu Moger if (rdt_alloc_capable && parent_kn == rdtgroup_default.kn) 304932ada3b9SXiaochen Shen return rdtgroup_mkdir_ctrl_mon(parent_kn, name, mode); 3050fa7d9493SBabu Moger 3051fa7d9493SBabu Moger /* 3052fa7d9493SBabu Moger * If RDT monitoring is supported and the parent directory is a valid 3053fa7d9493SBabu Moger * "mon_groups" directory, add a monitoring subdirectory. 3054fa7d9493SBabu Moger */ 3055fa7d9493SBabu Moger if (rdt_mon_capable && is_mon_groups(parent_kn, name)) 305632ada3b9SXiaochen Shen return rdtgroup_mkdir_mon(parent_kn, name, mode); 3057fa7d9493SBabu Moger 3058fa7d9493SBabu Moger return -EPERM; 3059fa7d9493SBabu Moger } 3060fa7d9493SBabu Moger 306119eb86a7SXiaochen Shen static int rdtgroup_rmdir_mon(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3062fa7d9493SBabu Moger { 3063fa7d9493SBabu Moger struct rdtgroup *prdtgrp = rdtgrp->mon.parent; 3064fa7d9493SBabu Moger int cpu; 3065fa7d9493SBabu Moger 3066fa7d9493SBabu Moger /* Give any tasks back to the parent group */ 3067fa7d9493SBabu Moger rdt_move_group_tasks(rdtgrp, prdtgrp, tmpmask); 3068fa7d9493SBabu Moger 3069fa7d9493SBabu Moger /* Update per cpu rmid of the moved CPUs first */ 3070fa7d9493SBabu Moger for_each_cpu(cpu, &rdtgrp->cpu_mask) 3071fa7d9493SBabu Moger per_cpu(pqr_state.default_rmid, cpu) = prdtgrp->mon.rmid; 3072fa7d9493SBabu Moger /* 3073fa7d9493SBabu Moger * Update the MSR on moved CPUs and CPUs which have moved 3074fa7d9493SBabu Moger * task running on them. 3075fa7d9493SBabu Moger */ 3076fa7d9493SBabu Moger cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3077fa7d9493SBabu Moger update_closid_rmid(tmpmask, NULL); 3078fa7d9493SBabu Moger 3079fa7d9493SBabu Moger rdtgrp->flags = RDT_DELETED; 3080fa7d9493SBabu Moger free_rmid(rdtgrp->mon.rmid); 3081fa7d9493SBabu Moger 3082fa7d9493SBabu Moger /* 3083fa7d9493SBabu Moger * Remove the rdtgrp from the parent ctrl_mon group's list 3084fa7d9493SBabu Moger */ 3085fa7d9493SBabu Moger WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list)); 3086fa7d9493SBabu Moger list_del(&rdtgrp->mon.crdtgrp_list); 3087fa7d9493SBabu Moger 3088fa7d9493SBabu Moger kernfs_remove(rdtgrp->kn); 3089fa7d9493SBabu Moger 3090fa7d9493SBabu Moger return 0; 3091fa7d9493SBabu Moger } 3092fa7d9493SBabu Moger 309319eb86a7SXiaochen Shen static int rdtgroup_ctrl_remove(struct rdtgroup *rdtgrp) 3094fa7d9493SBabu Moger { 3095fa7d9493SBabu Moger rdtgrp->flags = RDT_DELETED; 3096fa7d9493SBabu Moger list_del(&rdtgrp->rdtgroup_list); 3097fa7d9493SBabu Moger 3098fa7d9493SBabu Moger kernfs_remove(rdtgrp->kn); 3099fa7d9493SBabu Moger return 0; 3100fa7d9493SBabu Moger } 3101fa7d9493SBabu Moger 310219eb86a7SXiaochen Shen static int rdtgroup_rmdir_ctrl(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3103fa7d9493SBabu Moger { 3104fa7d9493SBabu Moger int cpu; 3105fa7d9493SBabu Moger 3106fa7d9493SBabu Moger /* Give any tasks back to the default group */ 3107fa7d9493SBabu Moger rdt_move_group_tasks(rdtgrp, &rdtgroup_default, tmpmask); 3108fa7d9493SBabu Moger 3109fa7d9493SBabu Moger /* Give any CPUs back to the default group */ 3110fa7d9493SBabu Moger cpumask_or(&rdtgroup_default.cpu_mask, 3111fa7d9493SBabu Moger &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 3112fa7d9493SBabu Moger 3113fa7d9493SBabu Moger /* Update per cpu closid and rmid of the moved CPUs first */ 3114fa7d9493SBabu Moger for_each_cpu(cpu, &rdtgrp->cpu_mask) { 3115fa7d9493SBabu Moger per_cpu(pqr_state.default_closid, cpu) = rdtgroup_default.closid; 3116fa7d9493SBabu Moger per_cpu(pqr_state.default_rmid, cpu) = rdtgroup_default.mon.rmid; 3117fa7d9493SBabu Moger } 3118fa7d9493SBabu Moger 3119fa7d9493SBabu Moger /* 3120fa7d9493SBabu Moger * Update the MSR on moved CPUs and CPUs which have moved 3121fa7d9493SBabu Moger * task running on them. 3122fa7d9493SBabu Moger */ 3123fa7d9493SBabu Moger cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3124fa7d9493SBabu Moger update_closid_rmid(tmpmask, NULL); 3125fa7d9493SBabu Moger 3126fa7d9493SBabu Moger closid_free(rdtgrp->closid); 3127fa7d9493SBabu Moger free_rmid(rdtgrp->mon.rmid); 3128fa7d9493SBabu Moger 312919eb86a7SXiaochen Shen rdtgroup_ctrl_remove(rdtgrp); 3130074fadeeSXiaochen Shen 3131fa7d9493SBabu Moger /* 3132fa7d9493SBabu Moger * Free all the child monitor group rmids. 3133fa7d9493SBabu Moger */ 3134fa7d9493SBabu Moger free_all_child_rdtgrp(rdtgrp); 3135fa7d9493SBabu Moger 3136fa7d9493SBabu Moger return 0; 3137fa7d9493SBabu Moger } 3138fa7d9493SBabu Moger 3139fa7d9493SBabu Moger static int rdtgroup_rmdir(struct kernfs_node *kn) 3140fa7d9493SBabu Moger { 3141fa7d9493SBabu Moger struct kernfs_node *parent_kn = kn->parent; 3142fa7d9493SBabu Moger struct rdtgroup *rdtgrp; 3143fa7d9493SBabu Moger cpumask_var_t tmpmask; 3144fa7d9493SBabu Moger int ret = 0; 3145fa7d9493SBabu Moger 3146fa7d9493SBabu Moger if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 3147fa7d9493SBabu Moger return -ENOMEM; 3148fa7d9493SBabu Moger 3149fa7d9493SBabu Moger rdtgrp = rdtgroup_kn_lock_live(kn); 3150fa7d9493SBabu Moger if (!rdtgrp) { 3151fa7d9493SBabu Moger ret = -EPERM; 3152fa7d9493SBabu Moger goto out; 3153fa7d9493SBabu Moger } 3154fa7d9493SBabu Moger 3155fa7d9493SBabu Moger /* 3156fa7d9493SBabu Moger * If the rdtgroup is a ctrl_mon group and parent directory 3157fa7d9493SBabu Moger * is the root directory, remove the ctrl_mon group. 3158fa7d9493SBabu Moger * 3159fa7d9493SBabu Moger * If the rdtgroup is a mon group and parent directory 3160fa7d9493SBabu Moger * is a valid "mon_groups" directory, remove the mon group. 3161fa7d9493SBabu Moger */ 3162b0151da5SReinette Chatre if (rdtgrp->type == RDTCTRL_GROUP && parent_kn == rdtgroup_default.kn && 3163b0151da5SReinette Chatre rdtgrp != &rdtgroup_default) { 3164fa7d9493SBabu Moger if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 3165fa7d9493SBabu Moger rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 316619eb86a7SXiaochen Shen ret = rdtgroup_ctrl_remove(rdtgrp); 3167fa7d9493SBabu Moger } else { 316819eb86a7SXiaochen Shen ret = rdtgroup_rmdir_ctrl(rdtgrp, tmpmask); 3169fa7d9493SBabu Moger } 3170fa7d9493SBabu Moger } else if (rdtgrp->type == RDTMON_GROUP && 3171fa7d9493SBabu Moger is_mon_groups(parent_kn, kn->name)) { 317219eb86a7SXiaochen Shen ret = rdtgroup_rmdir_mon(rdtgrp, tmpmask); 3173fa7d9493SBabu Moger } else { 3174fa7d9493SBabu Moger ret = -EPERM; 3175fa7d9493SBabu Moger } 3176fa7d9493SBabu Moger 3177fa7d9493SBabu Moger out: 3178fa7d9493SBabu Moger rdtgroup_kn_unlock(kn); 3179fa7d9493SBabu Moger free_cpumask_var(tmpmask); 3180fa7d9493SBabu Moger return ret; 3181fa7d9493SBabu Moger } 3182fa7d9493SBabu Moger 3183fa7d9493SBabu Moger static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf) 3184fa7d9493SBabu Moger { 318563c8b123SJames Morse if (rdt_resources_all[RDT_RESOURCE_L3DATA].r_resctrl.alloc_enabled) 3186fa7d9493SBabu Moger seq_puts(seq, ",cdp"); 3187fa7d9493SBabu Moger 318863c8b123SJames Morse if (rdt_resources_all[RDT_RESOURCE_L2DATA].r_resctrl.alloc_enabled) 3189fa7d9493SBabu Moger seq_puts(seq, ",cdpl2"); 3190fa7d9493SBabu Moger 319163c8b123SJames Morse if (is_mba_sc(&rdt_resources_all[RDT_RESOURCE_MBA].r_resctrl)) 3192fa7d9493SBabu Moger seq_puts(seq, ",mba_MBps"); 3193fa7d9493SBabu Moger 3194fa7d9493SBabu Moger return 0; 3195fa7d9493SBabu Moger } 3196fa7d9493SBabu Moger 3197fa7d9493SBabu Moger static struct kernfs_syscall_ops rdtgroup_kf_syscall_ops = { 3198fa7d9493SBabu Moger .mkdir = rdtgroup_mkdir, 3199fa7d9493SBabu Moger .rmdir = rdtgroup_rmdir, 3200fa7d9493SBabu Moger .show_options = rdtgroup_show_options, 3201fa7d9493SBabu Moger }; 3202fa7d9493SBabu Moger 3203fa7d9493SBabu Moger static int __init rdtgroup_setup_root(void) 3204fa7d9493SBabu Moger { 3205fa7d9493SBabu Moger int ret; 3206fa7d9493SBabu Moger 3207fa7d9493SBabu Moger rdt_root = kernfs_create_root(&rdtgroup_kf_syscall_ops, 3208fa7d9493SBabu Moger KERNFS_ROOT_CREATE_DEACTIVATED | 3209fa7d9493SBabu Moger KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK, 3210fa7d9493SBabu Moger &rdtgroup_default); 3211fa7d9493SBabu Moger if (IS_ERR(rdt_root)) 3212fa7d9493SBabu Moger return PTR_ERR(rdt_root); 3213fa7d9493SBabu Moger 3214fa7d9493SBabu Moger mutex_lock(&rdtgroup_mutex); 3215fa7d9493SBabu Moger 3216fa7d9493SBabu Moger rdtgroup_default.closid = 0; 3217fa7d9493SBabu Moger rdtgroup_default.mon.rmid = 0; 3218fa7d9493SBabu Moger rdtgroup_default.type = RDTCTRL_GROUP; 3219fa7d9493SBabu Moger INIT_LIST_HEAD(&rdtgroup_default.mon.crdtgrp_list); 3220fa7d9493SBabu Moger 3221fa7d9493SBabu Moger list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups); 3222fa7d9493SBabu Moger 3223fa7d9493SBabu Moger ret = rdtgroup_add_files(rdt_root->kn, RF_CTRL_BASE); 3224fa7d9493SBabu Moger if (ret) { 3225fa7d9493SBabu Moger kernfs_destroy_root(rdt_root); 3226fa7d9493SBabu Moger goto out; 3227fa7d9493SBabu Moger } 3228fa7d9493SBabu Moger 3229fa7d9493SBabu Moger rdtgroup_default.kn = rdt_root->kn; 3230fa7d9493SBabu Moger kernfs_activate(rdtgroup_default.kn); 3231fa7d9493SBabu Moger 3232fa7d9493SBabu Moger out: 3233fa7d9493SBabu Moger mutex_unlock(&rdtgroup_mutex); 3234fa7d9493SBabu Moger 3235fa7d9493SBabu Moger return ret; 3236fa7d9493SBabu Moger } 3237fa7d9493SBabu Moger 3238fa7d9493SBabu Moger /* 3239fa7d9493SBabu Moger * rdtgroup_init - rdtgroup initialization 3240fa7d9493SBabu Moger * 3241fa7d9493SBabu Moger * Setup resctrl file system including set up root, create mount point, 3242fa7d9493SBabu Moger * register rdtgroup filesystem, and initialize files under root directory. 3243fa7d9493SBabu Moger * 3244fa7d9493SBabu Moger * Return: 0 on success or -errno 3245fa7d9493SBabu Moger */ 3246fa7d9493SBabu Moger int __init rdtgroup_init(void) 3247fa7d9493SBabu Moger { 3248fa7d9493SBabu Moger int ret = 0; 3249fa7d9493SBabu Moger 3250fa7d9493SBabu Moger seq_buf_init(&last_cmd_status, last_cmd_status_buf, 3251fa7d9493SBabu Moger sizeof(last_cmd_status_buf)); 3252fa7d9493SBabu Moger 3253fa7d9493SBabu Moger ret = rdtgroup_setup_root(); 3254fa7d9493SBabu Moger if (ret) 3255fa7d9493SBabu Moger return ret; 3256fa7d9493SBabu Moger 3257fa7d9493SBabu Moger ret = sysfs_create_mount_point(fs_kobj, "resctrl"); 3258fa7d9493SBabu Moger if (ret) 3259fa7d9493SBabu Moger goto cleanup_root; 3260fa7d9493SBabu Moger 3261fa7d9493SBabu Moger ret = register_filesystem(&rdt_fs_type); 3262fa7d9493SBabu Moger if (ret) 3263fa7d9493SBabu Moger goto cleanup_mountpoint; 3264fa7d9493SBabu Moger 3265fa7d9493SBabu Moger /* 3266fa7d9493SBabu Moger * Adding the resctrl debugfs directory here may not be ideal since 3267fa7d9493SBabu Moger * it would let the resctrl debugfs directory appear on the debugfs 3268fa7d9493SBabu Moger * filesystem before the resctrl filesystem is mounted. 3269fa7d9493SBabu Moger * It may also be ok since that would enable debugging of RDT before 3270fa7d9493SBabu Moger * resctrl is mounted. 3271fa7d9493SBabu Moger * The reason why the debugfs directory is created here and not in 3272ae0fbeddSJames Morse * rdt_get_tree() is because rdt_get_tree() takes rdtgroup_mutex and 3273fa7d9493SBabu Moger * during the debugfs directory creation also &sb->s_type->i_mutex_key 3274fa7d9493SBabu Moger * (the lockdep class of inode->i_rwsem). Other filesystem 3275fa7d9493SBabu Moger * interactions (eg. SyS_getdents) have the lock ordering: 3276c1e8d7c6SMichel Lespinasse * &sb->s_type->i_mutex_key --> &mm->mmap_lock 3277c1e8d7c6SMichel Lespinasse * During mmap(), called with &mm->mmap_lock, the rdtgroup_mutex 3278fa7d9493SBabu Moger * is taken, thus creating dependency: 3279c1e8d7c6SMichel Lespinasse * &mm->mmap_lock --> rdtgroup_mutex for the latter that can cause 3280fa7d9493SBabu Moger * issues considering the other two lock dependencies. 3281fa7d9493SBabu Moger * By creating the debugfs directory here we avoid a dependency 3282fa7d9493SBabu Moger * that may cause deadlock (even though file operations cannot 3283fa7d9493SBabu Moger * occur until the filesystem is mounted, but I do not know how to 3284fa7d9493SBabu Moger * tell lockdep that). 3285fa7d9493SBabu Moger */ 3286fa7d9493SBabu Moger debugfs_resctrl = debugfs_create_dir("resctrl", NULL); 3287fa7d9493SBabu Moger 3288fa7d9493SBabu Moger return 0; 3289fa7d9493SBabu Moger 3290fa7d9493SBabu Moger cleanup_mountpoint: 3291fa7d9493SBabu Moger sysfs_remove_mount_point(fs_kobj, "resctrl"); 3292fa7d9493SBabu Moger cleanup_root: 3293fa7d9493SBabu Moger kernfs_destroy_root(rdt_root); 3294fa7d9493SBabu Moger 3295fa7d9493SBabu Moger return ret; 3296fa7d9493SBabu Moger } 3297fa7d9493SBabu Moger 3298fa7d9493SBabu Moger void __exit rdtgroup_exit(void) 3299fa7d9493SBabu Moger { 3300fa7d9493SBabu Moger debugfs_remove_recursive(debugfs_resctrl); 3301fa7d9493SBabu Moger unregister_filesystem(&rdt_fs_type); 3302fa7d9493SBabu Moger sysfs_remove_mount_point(fs_kobj, "resctrl"); 3303fa7d9493SBabu Moger kernfs_destroy_root(rdt_root); 3304fa7d9493SBabu Moger } 3305