-1

Documentation/arch/x86/index.rst

reviewed

··· 32 32 pti 33 33 mds 34 34 microcode 35 35 - resctrl 36 35 tsx_async_abort 37 36 buslock 38 37 usb-legacy-support

+3 -3

Documentation/arch/x86/resctrl.rst Documentation/filesystems/resctrl.rst

reviewed

··· 1 1 .. SPDX-License-Identifier: GPL-2.0 2 2 .. include:: <isonum.txt> 3 3 4 4 - =========================================== 5 5 - User Interface for Resource Control feature 6 6 - =========================================== 4 4 + ===================================================== 5 5 + User Interface for Resource Control feature (resctrl) 6 6 + ===================================================== 7 7 8 8 :Copyright: |copy| 2016 Intel Corporation 9 9 :Authors: - Fenghua Yu <fenghua.yu@intel.com>

+1

Documentation/filesystems/index.rst

reviewed

··· 113 113 qnx6 114 114 ramfs-rootfs-initramfs 115 115 relay 116 116 + resctrl 116 117 romfs 117 118 smb/index 118 119 spufs/index

+4 -1

MAINTAINERS

reviewed

··· 20501 20501 RDT - RESOURCE ALLOCATION 20502 20502 M: Tony Luck <tony.luck@intel.com> 20503 20503 M: Reinette Chatre <reinette.chatre@intel.com> 20504 20504 + R: Dave Martin <Dave.Martin@arm.com> 20505 20505 + R: James Morse <james.morse@arm.com> 20504 20506 L: linux-kernel@vger.kernel.org 20505 20507 S: Supported 20506 20506 - F: Documentation/arch/x86/resctrl* 20508 20508 + F: Documentation/filesystems/resctrl.rst 20507 20509 F: arch/x86/include/asm/resctrl.h 20508 20510 F: arch/x86/kernel/cpu/resctrl/ 20511 20511 + F: fs/resctrl/ 20509 20512 F: include/linux/resctrl*.h 20510 20513 F: tools/testing/selftests/resctrl/ 20511 20514

+8

arch/Kconfig

reviewed

··· 1518 1518 config ARCH_HAS_PHYS_TO_DMA 1519 1519 bool 1520 1520 1521 1521 + config ARCH_HAS_CPU_RESCTRL 1522 1522 + bool 1523 1523 + help 1524 1524 + An architecture selects this option to indicate that the necessary 1525 1525 + hooks are provided to support the common memory system usage 1526 1526 + monitoring and control interfaces provided by the 'resctrl' 1527 1527 + filesystem (see RESCTRL_FS). 1528 1528 + 1521 1529 config HAVE_ARCH_COMPILER_H 1522 1530 bool 1523 1531 help

+3 -8

arch/x86/Kconfig

reviewed

··· 507 507 config X86_CPU_RESCTRL 508 508 bool "x86 CPU resource control support" 509 509 depends on X86 && (CPU_SUP_INTEL || CPU_SUP_AMD) 510 510 - select KERNFS 511 511 - select PROC_CPU_RESCTRL if PROC_FS 510 510 + depends on MISC_FILESYSTEMS 511 511 + select ARCH_HAS_CPU_RESCTRL 512 512 + select RESCTRL_FS 512 513 select RESCTRL_FS_PSEUDO_LOCK 513 514 help 514 515 Enable x86 CPU resource control support. ··· 526 525 Platform Quality of Service Extensions manual. 527 526 528 527 Say N if unsure. 529 529 - 530 530 - config RESCTRL_FS_PSEUDO_LOCK 531 531 - bool 532 532 - help 533 533 - Software mechanism to pin data in a cache portion using 534 534 - micro-architecture specific knowledge. 535 528 536 529 config X86_FRED 537 530 bool "Flexible Return and Event Delivery"

+8 -11

arch/x86/include/asm/resctrl.h

reviewed

··· 177 177 return READ_ONCE(tsk->rmid) == rmid; 178 178 } 179 179 180 180 - static inline void resctrl_sched_in(struct task_struct *tsk) 180 180 + static inline void resctrl_arch_sched_in(struct task_struct *tsk) 181 181 { 182 182 if (static_branch_likely(&rdt_enable_key)) 183 183 __resctrl_sched_in(tsk); ··· 196 196 197 197 /* x86 can always read an rmid, nothing needs allocating */ 198 198 struct rdt_resource; 199 199 - static inline void *resctrl_arch_mon_ctx_alloc(struct rdt_resource *r, int evtid) 199 199 + static inline void *resctrl_arch_mon_ctx_alloc(struct rdt_resource *r, 200 200 + enum resctrl_event_id evtid) 200 201 { 201 202 might_sleep(); 202 203 return NULL; 203 203 - }; 204 204 + } 204 205 205 205 - static inline void resctrl_arch_mon_ctx_free(struct rdt_resource *r, int evtid, 206 206 - void *ctx) { }; 206 206 + static inline void resctrl_arch_mon_ctx_free(struct rdt_resource *r, 207 207 + enum resctrl_event_id evtid, 208 208 + void *ctx) { } 207 209 208 208 - u64 resctrl_arch_get_prefetch_disable_bits(void); 209 209 - int resctrl_arch_pseudo_lock_fn(void *_plr); 210 210 - int resctrl_arch_measure_cycles_lat_fn(void *_plr); 211 211 - int resctrl_arch_measure_l2_residency(void *_plr); 212 212 - int resctrl_arch_measure_l3_residency(void *_plr); 213 210 void resctrl_cpu_detect(struct cpuinfo_x86 *c); 214 211 215 212 #else 216 213 217 217 - static inline void resctrl_sched_in(struct task_struct *tsk) {} 214 214 + static inline void resctrl_arch_sched_in(struct task_struct *tsk) {} 218 215 static inline void resctrl_cpu_detect(struct cpuinfo_x86 *c) {} 219 216 220 217 #endif /* CONFIG_X86_CPU_RESCTRL */

+2

arch/x86/kernel/cpu/resctrl/Makefile

reviewed

··· 2 2 obj-$(CONFIG_X86_CPU_RESCTRL) += core.o rdtgroup.o monitor.o 3 3 obj-$(CONFIG_X86_CPU_RESCTRL) += ctrlmondata.o 4 4 obj-$(CONFIG_RESCTRL_FS_PSEUDO_LOCK) += pseudo_lock.o 5 5 + 6 6 + # To allow define_trace.h's recursive include: 5 7 CFLAGS_pseudo_lock.o = -I$(src)

+8 -23

arch/x86/kernel/cpu/resctrl/core.c

reviewed

··· 61 61 [RDT_RESOURCE_L3] = 62 62 { 63 63 .r_resctrl = { 64 64 - .rid = RDT_RESOURCE_L3, 65 64 .name = "L3", 66 65 .ctrl_scope = RESCTRL_L3_CACHE, 67 66 .mon_scope = RESCTRL_L3_CACHE, ··· 74 75 [RDT_RESOURCE_L2] = 75 76 { 76 77 .r_resctrl = { 77 77 - .rid = RDT_RESOURCE_L2, 78 78 .name = "L2", 79 79 .ctrl_scope = RESCTRL_L2_CACHE, 80 80 .ctrl_domains = ctrl_domain_init(RDT_RESOURCE_L2), ··· 85 87 [RDT_RESOURCE_MBA] = 86 88 { 87 89 .r_resctrl = { 88 88 - .rid = RDT_RESOURCE_MBA, 89 90 .name = "MB", 90 91 .ctrl_scope = RESCTRL_L3_CACHE, 91 92 .ctrl_domains = ctrl_domain_init(RDT_RESOURCE_MBA), ··· 94 97 [RDT_RESOURCE_SMBA] = 95 98 { 96 99 .r_resctrl = { 97 97 - .rid = RDT_RESOURCE_SMBA, 98 100 .name = "SMBA", 99 101 .ctrl_scope = RESCTRL_L3_CACHE, 100 102 .ctrl_domains = ctrl_domain_init(RDT_RESOURCE_SMBA), ··· 159 163 r->alloc_capable = true; 160 164 161 165 rdt_alloc_capable = true; 162 162 - } 163 163 - 164 164 - bool is_mba_sc(struct rdt_resource *r) 165 165 - { 166 166 - if (!r) 167 167 - r = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 168 168 - 169 169 - /* 170 170 - * The software controller support is only applicable to MBA resource. 171 171 - * Make sure to check for resource type. 172 172 - */ 173 173 - if (r->rid != RDT_RESOURCE_MBA) 174 174 - return false; 175 175 - 176 176 - return r->membw.mba_sc; 177 166 } 178 167 179 168 /* ··· 719 738 bool force_off, force_on; 720 739 }; 721 740 722 722 - static struct rdt_options rdt_options[] __initdata = { 741 741 + static struct rdt_options rdt_options[] __ro_after_init = { 723 742 RDT_OPT(RDT_FLAG_CMT, "cmt", X86_FEATURE_CQM_OCCUP_LLC), 724 743 RDT_OPT(RDT_FLAG_MBM_TOTAL, "mbmtotal", X86_FEATURE_CQM_MBM_TOTAL), 725 744 RDT_OPT(RDT_FLAG_MBM_LOCAL, "mbmlocal", X86_FEATURE_CQM_MBM_LOCAL), ··· 759 778 } 760 779 __setup("rdt", set_rdt_options); 761 780 762 762 - bool __init rdt_cpu_has(int flag) 781 781 + bool rdt_cpu_has(int flag) 763 782 { 764 783 bool ret = boot_cpu_has(flag); 765 784 struct rdt_options *o; ··· 779 798 return ret; 780 799 } 781 800 782 782 - __init bool resctrl_arch_is_evt_configurable(enum resctrl_event_id evt) 801 801 + bool resctrl_arch_is_evt_configurable(enum resctrl_event_id evt) 783 802 { 784 803 if (!rdt_cpu_has(X86_FEATURE_BMEC)) 785 804 return false; ··· 993 1012 static int __init resctrl_arch_late_init(void) 994 1013 { 995 1014 struct rdt_resource *r; 996 996 - int state, ret; 1015 1015 + int state, ret, i; 1016 1016 + 1017 1017 + /* for_each_rdt_resource() requires all rid to be initialised. */ 1018 1018 + for (i = 0; i < RDT_NUM_RESOURCES; i++) 1019 1019 + rdt_resources_all[i].r_resctrl.rid = i; 997 1020 998 1021 /* 999 1022 * Initialize functions(or definitions) that are different

-635

arch/x86/kernel/cpu/resctrl/ctrlmondata.c

reviewed

··· 16 16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 17 17 18 18 #include <linux/cpu.h> 19 19 - #include <linux/kernfs.h> 20 20 - #include <linux/seq_file.h> 21 21 - #include <linux/slab.h> 22 22 - #include <linux/tick.h> 23 19 24 20 #include "internal.h" 25 25 - 26 26 - struct rdt_parse_data { 27 27 - struct rdtgroup *rdtgrp; 28 28 - char *buf; 29 29 - }; 30 30 - 31 31 - typedef int (ctrlval_parser_t)(struct rdt_parse_data *data, 32 32 - struct resctrl_schema *s, 33 33 - struct rdt_ctrl_domain *d); 34 34 - 35 35 - /* 36 36 - * Check whether MBA bandwidth percentage value is correct. The value is 37 37 - * checked against the minimum and max bandwidth values specified by the 38 38 - * hardware. The allocated bandwidth percentage is rounded to the next 39 39 - * control step available on the hardware. 40 40 - */ 41 41 - static bool bw_validate(char *buf, u32 *data, struct rdt_resource *r) 42 42 - { 43 43 - int ret; 44 44 - u32 bw; 45 45 - 46 46 - /* 47 47 - * Only linear delay values is supported for current Intel SKUs. 48 48 - */ 49 49 - if (!r->membw.delay_linear && r->membw.arch_needs_linear) { 50 50 - rdt_last_cmd_puts("No support for non-linear MB domains\n"); 51 51 - return false; 52 52 - } 53 53 - 54 54 - ret = kstrtou32(buf, 10, &bw); 55 55 - if (ret) { 56 56 - rdt_last_cmd_printf("Invalid MB value %s\n", buf); 57 57 - return false; 58 58 - } 59 59 - 60 60 - /* Nothing else to do if software controller is enabled. */ 61 61 - if (is_mba_sc(r)) { 62 62 - *data = bw; 63 63 - return true; 64 64 - } 65 65 - 66 66 - if (bw < r->membw.min_bw || bw > r->membw.max_bw) { 67 67 - rdt_last_cmd_printf("MB value %u out of range [%d,%d]\n", 68 68 - bw, r->membw.min_bw, r->membw.max_bw); 69 69 - return false; 70 70 - } 71 71 - 72 72 - *data = roundup(bw, (unsigned long)r->membw.bw_gran); 73 73 - return true; 74 74 - } 75 75 - 76 76 - static int parse_bw(struct rdt_parse_data *data, struct resctrl_schema *s, 77 77 - struct rdt_ctrl_domain *d) 78 78 - { 79 79 - struct resctrl_staged_config *cfg; 80 80 - u32 closid = data->rdtgrp->closid; 81 81 - struct rdt_resource *r = s->res; 82 82 - u32 bw_val; 83 83 - 84 84 - cfg = &d->staged_config[s->conf_type]; 85 85 - if (cfg->have_new_ctrl) { 86 86 - rdt_last_cmd_printf("Duplicate domain %d\n", d->hdr.id); 87 87 - return -EINVAL; 88 88 - } 89 89 - 90 90 - if (!bw_validate(data->buf, &bw_val, r)) 91 91 - return -EINVAL; 92 92 - 93 93 - if (is_mba_sc(r)) { 94 94 - d->mbps_val[closid] = bw_val; 95 95 - return 0; 96 96 - } 97 97 - 98 98 - cfg->new_ctrl = bw_val; 99 99 - cfg->have_new_ctrl = true; 100 100 - 101 101 - return 0; 102 102 - } 103 103 - 104 104 - /* 105 105 - * Check whether a cache bit mask is valid. 106 106 - * On Intel CPUs, non-contiguous 1s value support is indicated by CPUID: 107 107 - * - CPUID.0x10.1:ECX[3]: L3 non-contiguous 1s value supported if 1 108 108 - * - CPUID.0x10.2:ECX[3]: L2 non-contiguous 1s value supported if 1 109 109 - * 110 110 - * Haswell does not support a non-contiguous 1s value and additionally 111 111 - * requires at least two bits set. 112 112 - * AMD allows non-contiguous bitmasks. 113 113 - */ 114 114 - static bool cbm_validate(char *buf, u32 *data, struct rdt_resource *r) 115 115 - { 116 116 - u32 supported_bits = BIT_MASK(r->cache.cbm_len) - 1; 117 117 - unsigned int cbm_len = r->cache.cbm_len; 118 118 - unsigned long first_bit, zero_bit, val; 119 119 - int ret; 120 120 - 121 121 - ret = kstrtoul(buf, 16, &val); 122 122 - if (ret) { 123 123 - rdt_last_cmd_printf("Non-hex character in the mask %s\n", buf); 124 124 - return false; 125 125 - } 126 126 - 127 127 - if ((r->cache.min_cbm_bits > 0 && val == 0) || val > supported_bits) { 128 128 - rdt_last_cmd_puts("Mask out of range\n"); 129 129 - return false; 130 130 - } 131 131 - 132 132 - first_bit = find_first_bit(&val, cbm_len); 133 133 - zero_bit = find_next_zero_bit(&val, cbm_len, first_bit); 134 134 - 135 135 - /* Are non-contiguous bitmasks allowed? */ 136 136 - if (!r->cache.arch_has_sparse_bitmasks && 137 137 - (find_next_bit(&val, cbm_len, zero_bit) < cbm_len)) { 138 138 - rdt_last_cmd_printf("The mask %lx has non-consecutive 1-bits\n", val); 139 139 - return false; 140 140 - } 141 141 - 142 142 - if ((zero_bit - first_bit) < r->cache.min_cbm_bits) { 143 143 - rdt_last_cmd_printf("Need at least %d bits in the mask\n", 144 144 - r->cache.min_cbm_bits); 145 145 - return false; 146 146 - } 147 147 - 148 148 - *data = val; 149 149 - return true; 150 150 - } 151 151 - 152 152 - /* 153 153 - * Read one cache bit mask (hex). Check that it is valid for the current 154 154 - * resource type. 155 155 - */ 156 156 - static int parse_cbm(struct rdt_parse_data *data, struct resctrl_schema *s, 157 157 - struct rdt_ctrl_domain *d) 158 158 - { 159 159 - struct rdtgroup *rdtgrp = data->rdtgrp; 160 160 - struct resctrl_staged_config *cfg; 161 161 - struct rdt_resource *r = s->res; 162 162 - u32 cbm_val; 163 163 - 164 164 - cfg = &d->staged_config[s->conf_type]; 165 165 - if (cfg->have_new_ctrl) { 166 166 - rdt_last_cmd_printf("Duplicate domain %d\n", d->hdr.id); 167 167 - return -EINVAL; 168 168 - } 169 169 - 170 170 - /* 171 171 - * Cannot set up more than one pseudo-locked region in a cache 172 172 - * hierarchy. 173 173 - */ 174 174 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP && 175 175 - rdtgroup_pseudo_locked_in_hierarchy(d)) { 176 176 - rdt_last_cmd_puts("Pseudo-locked region in hierarchy\n"); 177 177 - return -EINVAL; 178 178 - } 179 179 - 180 180 - if (!cbm_validate(data->buf, &cbm_val, r)) 181 181 - return -EINVAL; 182 182 - 183 183 - if ((rdtgrp->mode == RDT_MODE_EXCLUSIVE || 184 184 - rdtgrp->mode == RDT_MODE_SHAREABLE) && 185 185 - rdtgroup_cbm_overlaps_pseudo_locked(d, cbm_val)) { 186 186 - rdt_last_cmd_puts("CBM overlaps with pseudo-locked region\n"); 187 187 - return -EINVAL; 188 188 - } 189 189 - 190 190 - /* 191 191 - * The CBM may not overlap with the CBM of another closid if 192 192 - * either is exclusive. 193 193 - */ 194 194 - if (rdtgroup_cbm_overlaps(s, d, cbm_val, rdtgrp->closid, true)) { 195 195 - rdt_last_cmd_puts("Overlaps with exclusive group\n"); 196 196 - return -EINVAL; 197 197 - } 198 198 - 199 199 - if (rdtgroup_cbm_overlaps(s, d, cbm_val, rdtgrp->closid, false)) { 200 200 - if (rdtgrp->mode == RDT_MODE_EXCLUSIVE || 201 201 - rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 202 202 - rdt_last_cmd_puts("Overlaps with other group\n"); 203 203 - return -EINVAL; 204 204 - } 205 205 - } 206 206 - 207 207 - cfg->new_ctrl = cbm_val; 208 208 - cfg->have_new_ctrl = true; 209 209 - 210 210 - return 0; 211 211 - } 212 212 - 213 213 - /* 214 214 - * For each domain in this resource we expect to find a series of: 215 215 - * id=mask 216 216 - * separated by ";". The "id" is in decimal, and must match one of 217 217 - * the "id"s for this resource. 218 218 - */ 219 219 - static int parse_line(char *line, struct resctrl_schema *s, 220 220 - struct rdtgroup *rdtgrp) 221 221 - { 222 222 - enum resctrl_conf_type t = s->conf_type; 223 223 - ctrlval_parser_t *parse_ctrlval = NULL; 224 224 - struct resctrl_staged_config *cfg; 225 225 - struct rdt_resource *r = s->res; 226 226 - struct rdt_parse_data data; 227 227 - struct rdt_ctrl_domain *d; 228 228 - char *dom = NULL, *id; 229 229 - unsigned long dom_id; 230 230 - 231 231 - /* Walking r->domains, ensure it can't race with cpuhp */ 232 232 - lockdep_assert_cpus_held(); 233 233 - 234 234 - switch (r->schema_fmt) { 235 235 - case RESCTRL_SCHEMA_BITMAP: 236 236 - parse_ctrlval = &parse_cbm; 237 237 - break; 238 238 - case RESCTRL_SCHEMA_RANGE: 239 239 - parse_ctrlval = &parse_bw; 240 240 - break; 241 241 - } 242 242 - 243 243 - if (WARN_ON_ONCE(!parse_ctrlval)) 244 244 - return -EINVAL; 245 245 - 246 246 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP && 247 247 - (r->rid == RDT_RESOURCE_MBA || r->rid == RDT_RESOURCE_SMBA)) { 248 248 - rdt_last_cmd_puts("Cannot pseudo-lock MBA resource\n"); 249 249 - return -EINVAL; 250 250 - } 251 251 - 252 252 - next: 253 253 - if (!line || line[0] == '\0') 254 254 - return 0; 255 255 - dom = strsep(&line, ";"); 256 256 - id = strsep(&dom, "="); 257 257 - if (!dom || kstrtoul(id, 10, &dom_id)) { 258 258 - rdt_last_cmd_puts("Missing '=' or non-numeric domain\n"); 259 259 - return -EINVAL; 260 260 - } 261 261 - dom = strim(dom); 262 262 - list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 263 263 - if (d->hdr.id == dom_id) { 264 264 - data.buf = dom; 265 265 - data.rdtgrp = rdtgrp; 266 266 - if (parse_ctrlval(&data, s, d)) 267 267 - return -EINVAL; 268 268 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 269 269 - cfg = &d->staged_config[t]; 270 270 - /* 271 271 - * In pseudo-locking setup mode and just 272 272 - * parsed a valid CBM that should be 273 273 - * pseudo-locked. Only one locked region per 274 274 - * resource group and domain so just do 275 275 - * the required initialization for single 276 276 - * region and return. 277 277 - */ 278 278 - rdtgrp->plr->s = s; 279 279 - rdtgrp->plr->d = d; 280 280 - rdtgrp->plr->cbm = cfg->new_ctrl; 281 281 - d->plr = rdtgrp->plr; 282 282 - return 0; 283 283 - } 284 284 - goto next; 285 285 - } 286 286 - } 287 287 - return -EINVAL; 288 288 - } 289 21 290 22 int resctrl_arch_update_one(struct rdt_resource *r, struct rdt_ctrl_domain *d, 291 23 u32 closid, enum resctrl_conf_type t, u32 cfg_val) ··· 83 351 return 0; 84 352 } 85 353 86 86 - static int rdtgroup_parse_resource(char *resname, char *tok, 87 87 - struct rdtgroup *rdtgrp) 88 88 - { 89 89 - struct resctrl_schema *s; 90 90 - 91 91 - list_for_each_entry(s, &resctrl_schema_all, list) { 92 92 - if (!strcmp(resname, s->name) && rdtgrp->closid < s->num_closid) 93 93 - return parse_line(tok, s, rdtgrp); 94 94 - } 95 95 - rdt_last_cmd_printf("Unknown or unsupported resource name '%s'\n", resname); 96 96 - return -EINVAL; 97 97 - } 98 98 - 99 99 - ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of, 100 100 - char *buf, size_t nbytes, loff_t off) 101 101 - { 102 102 - struct resctrl_schema *s; 103 103 - struct rdtgroup *rdtgrp; 104 104 - struct rdt_resource *r; 105 105 - char *tok, *resname; 106 106 - int ret = 0; 107 107 - 108 108 - /* Valid input requires a trailing newline */ 109 109 - if (nbytes == 0 || buf[nbytes - 1] != '\n') 110 110 - return -EINVAL; 111 111 - buf[nbytes - 1] = '\0'; 112 112 - 113 113 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 114 114 - if (!rdtgrp) { 115 115 - rdtgroup_kn_unlock(of->kn); 116 116 - return -ENOENT; 117 117 - } 118 118 - rdt_last_cmd_clear(); 119 119 - 120 120 - /* 121 121 - * No changes to pseudo-locked region allowed. It has to be removed 122 122 - * and re-created instead. 123 123 - */ 124 124 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 125 125 - ret = -EINVAL; 126 126 - rdt_last_cmd_puts("Resource group is pseudo-locked\n"); 127 127 - goto out; 128 128 - } 129 129 - 130 130 - rdt_staged_configs_clear(); 131 131 - 132 132 - while ((tok = strsep(&buf, "\n")) != NULL) { 133 133 - resname = strim(strsep(&tok, ":")); 134 134 - if (!tok) { 135 135 - rdt_last_cmd_puts("Missing ':'\n"); 136 136 - ret = -EINVAL; 137 137 - goto out; 138 138 - } 139 139 - if (tok[0] == '\0') { 140 140 - rdt_last_cmd_printf("Missing '%s' value\n", resname); 141 141 - ret = -EINVAL; 142 142 - goto out; 143 143 - } 144 144 - ret = rdtgroup_parse_resource(resname, tok, rdtgrp); 145 145 - if (ret) 146 146 - goto out; 147 147 - } 148 148 - 149 149 - list_for_each_entry(s, &resctrl_schema_all, list) { 150 150 - r = s->res; 151 151 - 152 152 - /* 153 153 - * Writes to mba_sc resources update the software controller, 154 154 - * not the control MSR. 155 155 - */ 156 156 - if (is_mba_sc(r)) 157 157 - continue; 158 158 - 159 159 - ret = resctrl_arch_update_domains(r, rdtgrp->closid); 160 160 - if (ret) 161 161 - goto out; 162 162 - } 163 163 - 164 164 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 165 165 - /* 166 166 - * If pseudo-locking fails we keep the resource group in 167 167 - * mode RDT_MODE_PSEUDO_LOCKSETUP with its class of service 168 168 - * active and updated for just the domain the pseudo-locked 169 169 - * region was requested for. 170 170 - */ 171 171 - ret = rdtgroup_pseudo_lock_create(rdtgrp); 172 172 - } 173 173 - 174 174 - out: 175 175 - rdt_staged_configs_clear(); 176 176 - rdtgroup_kn_unlock(of->kn); 177 177 - return ret ?: nbytes; 178 178 - } 179 179 - 180 354 u32 resctrl_arch_get_config(struct rdt_resource *r, struct rdt_ctrl_domain *d, 181 355 u32 closid, enum resctrl_conf_type type) 182 356 { ··· 90 452 u32 idx = resctrl_get_config_index(closid, type); 91 453 92 454 return hw_dom->ctrl_val[idx]; 93 93 - } 94 94 - 95 95 - static void show_doms(struct seq_file *s, struct resctrl_schema *schema, int closid) 96 96 - { 97 97 - struct rdt_resource *r = schema->res; 98 98 - struct rdt_ctrl_domain *dom; 99 99 - bool sep = false; 100 100 - u32 ctrl_val; 101 101 - 102 102 - /* Walking r->domains, ensure it can't race with cpuhp */ 103 103 - lockdep_assert_cpus_held(); 104 104 - 105 105 - seq_printf(s, "%*s:", max_name_width, schema->name); 106 106 - list_for_each_entry(dom, &r->ctrl_domains, hdr.list) { 107 107 - if (sep) 108 108 - seq_puts(s, ";"); 109 109 - 110 110 - if (is_mba_sc(r)) 111 111 - ctrl_val = dom->mbps_val[closid]; 112 112 - else 113 113 - ctrl_val = resctrl_arch_get_config(r, dom, closid, 114 114 - schema->conf_type); 115 115 - 116 116 - seq_printf(s, schema->fmt_str, dom->hdr.id, ctrl_val); 117 117 - sep = true; 118 118 - } 119 119 - seq_puts(s, "\n"); 120 120 - } 121 121 - 122 122 - int rdtgroup_schemata_show(struct kernfs_open_file *of, 123 123 - struct seq_file *s, void *v) 124 124 - { 125 125 - struct resctrl_schema *schema; 126 126 - struct rdtgroup *rdtgrp; 127 127 - int ret = 0; 128 128 - u32 closid; 129 129 - 130 130 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 131 131 - if (rdtgrp) { 132 132 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 133 133 - list_for_each_entry(schema, &resctrl_schema_all, list) { 134 134 - seq_printf(s, "%s:uninitialized\n", schema->name); 135 135 - } 136 136 - } else if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 137 137 - if (!rdtgrp->plr->d) { 138 138 - rdt_last_cmd_clear(); 139 139 - rdt_last_cmd_puts("Cache domain offline\n"); 140 140 - ret = -ENODEV; 141 141 - } else { 142 142 - seq_printf(s, "%s:%d=%x\n", 143 143 - rdtgrp->plr->s->res->name, 144 144 - rdtgrp->plr->d->hdr.id, 145 145 - rdtgrp->plr->cbm); 146 146 - } 147 147 - } else { 148 148 - closid = rdtgrp->closid; 149 149 - list_for_each_entry(schema, &resctrl_schema_all, list) { 150 150 - if (closid < schema->num_closid) 151 151 - show_doms(s, schema, closid); 152 152 - } 153 153 - } 154 154 - } else { 155 155 - ret = -ENOENT; 156 156 - } 157 157 - rdtgroup_kn_unlock(of->kn); 158 158 - return ret; 159 159 - } 160 160 - 161 161 - static int smp_mon_event_count(void *arg) 162 162 - { 163 163 - mon_event_count(arg); 164 164 - 165 165 - return 0; 166 166 - } 167 167 - 168 168 - ssize_t rdtgroup_mba_mbps_event_write(struct kernfs_open_file *of, 169 169 - char *buf, size_t nbytes, loff_t off) 170 170 - { 171 171 - struct rdtgroup *rdtgrp; 172 172 - int ret = 0; 173 173 - 174 174 - /* Valid input requires a trailing newline */ 175 175 - if (nbytes == 0 || buf[nbytes - 1] != '\n') 176 176 - return -EINVAL; 177 177 - buf[nbytes - 1] = '\0'; 178 178 - 179 179 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 180 180 - if (!rdtgrp) { 181 181 - rdtgroup_kn_unlock(of->kn); 182 182 - return -ENOENT; 183 183 - } 184 184 - rdt_last_cmd_clear(); 185 185 - 186 186 - if (!strcmp(buf, "mbm_local_bytes")) { 187 187 - if (resctrl_arch_is_mbm_local_enabled()) 188 188 - rdtgrp->mba_mbps_event = QOS_L3_MBM_LOCAL_EVENT_ID; 189 189 - else 190 190 - ret = -EINVAL; 191 191 - } else if (!strcmp(buf, "mbm_total_bytes")) { 192 192 - if (resctrl_arch_is_mbm_total_enabled()) 193 193 - rdtgrp->mba_mbps_event = QOS_L3_MBM_TOTAL_EVENT_ID; 194 194 - else 195 195 - ret = -EINVAL; 196 196 - } else { 197 197 - ret = -EINVAL; 198 198 - } 199 199 - 200 200 - if (ret) 201 201 - rdt_last_cmd_printf("Unsupported event id '%s'\n", buf); 202 202 - 203 203 - rdtgroup_kn_unlock(of->kn); 204 204 - 205 205 - return ret ?: nbytes; 206 206 - } 207 207 - 208 208 - int rdtgroup_mba_mbps_event_show(struct kernfs_open_file *of, 209 209 - struct seq_file *s, void *v) 210 210 - { 211 211 - struct rdtgroup *rdtgrp; 212 212 - int ret = 0; 213 213 - 214 214 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 215 215 - 216 216 - if (rdtgrp) { 217 217 - switch (rdtgrp->mba_mbps_event) { 218 218 - case QOS_L3_MBM_LOCAL_EVENT_ID: 219 219 - seq_puts(s, "mbm_local_bytes\n"); 220 220 - break; 221 221 - case QOS_L3_MBM_TOTAL_EVENT_ID: 222 222 - seq_puts(s, "mbm_total_bytes\n"); 223 223 - break; 224 224 - default: 225 225 - pr_warn_once("Bad event %d\n", rdtgrp->mba_mbps_event); 226 226 - ret = -EINVAL; 227 227 - break; 228 228 - } 229 229 - } else { 230 230 - ret = -ENOENT; 231 231 - } 232 232 - 233 233 - rdtgroup_kn_unlock(of->kn); 234 234 - 235 235 - return ret; 236 236 - } 237 237 - 238 238 - struct rdt_domain_hdr *resctrl_find_domain(struct list_head *h, int id, 239 239 - struct list_head **pos) 240 240 - { 241 241 - struct rdt_domain_hdr *d; 242 242 - struct list_head *l; 243 243 - 244 244 - list_for_each(l, h) { 245 245 - d = list_entry(l, struct rdt_domain_hdr, list); 246 246 - /* When id is found, return its domain. */ 247 247 - if (id == d->id) 248 248 - return d; 249 249 - /* Stop searching when finding id's position in sorted list. */ 250 250 - if (id < d->id) 251 251 - break; 252 252 - } 253 253 - 254 254 - if (pos) 255 255 - *pos = l; 256 256 - 257 257 - return NULL; 258 258 - } 259 259 - 260 260 - void mon_event_read(struct rmid_read *rr, struct rdt_resource *r, 261 261 - struct rdt_mon_domain *d, struct rdtgroup *rdtgrp, 262 262 - cpumask_t *cpumask, int evtid, int first) 263 263 - { 264 264 - int cpu; 265 265 - 266 266 - /* When picking a CPU from cpu_mask, ensure it can't race with cpuhp */ 267 267 - lockdep_assert_cpus_held(); 268 268 - 269 269 - /* 270 270 - * Setup the parameters to pass to mon_event_count() to read the data. 271 271 - */ 272 272 - rr->rgrp = rdtgrp; 273 273 - rr->evtid = evtid; 274 274 - rr->r = r; 275 275 - rr->d = d; 276 276 - rr->first = first; 277 277 - rr->arch_mon_ctx = resctrl_arch_mon_ctx_alloc(r, evtid); 278 278 - if (IS_ERR(rr->arch_mon_ctx)) { 279 279 - rr->err = -EINVAL; 280 280 - return; 281 281 - } 282 282 - 283 283 - cpu = cpumask_any_housekeeping(cpumask, RESCTRL_PICK_ANY_CPU); 284 284 - 285 285 - /* 286 286 - * cpumask_any_housekeeping() prefers housekeeping CPUs, but 287 287 - * are all the CPUs nohz_full? If yes, pick a CPU to IPI. 288 288 - * MPAM's resctrl_arch_rmid_read() is unable to read the 289 289 - * counters on some platforms if its called in IRQ context. 290 290 - */ 291 291 - if (tick_nohz_full_cpu(cpu)) 292 292 - smp_call_function_any(cpumask, mon_event_count, rr, 1); 293 293 - else 294 294 - smp_call_on_cpu(cpu, smp_mon_event_count, rr, false); 295 295 - 296 296 - resctrl_arch_mon_ctx_free(r, evtid, rr->arch_mon_ctx); 297 297 - } 298 298 - 299 299 - int rdtgroup_mondata_show(struct seq_file *m, void *arg) 300 300 - { 301 301 - struct kernfs_open_file *of = m->private; 302 302 - struct rdt_domain_hdr *hdr; 303 303 - struct rmid_read rr = {0}; 304 304 - struct rdt_mon_domain *d; 305 305 - u32 resid, evtid, domid; 306 306 - struct rdtgroup *rdtgrp; 307 307 - struct rdt_resource *r; 308 308 - union mon_data_bits md; 309 309 - int ret = 0; 310 310 - 311 311 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 312 312 - if (!rdtgrp) { 313 313 - ret = -ENOENT; 314 314 - goto out; 315 315 - } 316 316 - 317 317 - md.priv = of->kn->priv; 318 318 - resid = md.u.rid; 319 319 - domid = md.u.domid; 320 320 - evtid = md.u.evtid; 321 321 - r = resctrl_arch_get_resource(resid); 322 322 - 323 323 - if (md.u.sum) { 324 324 - /* 325 325 - * This file requires summing across all domains that share 326 326 - * the L3 cache id that was provided in the "domid" field of the 327 327 - * mon_data_bits union. Search all domains in the resource for 328 328 - * one that matches this cache id. 329 329 - */ 330 330 - list_for_each_entry(d, &r->mon_domains, hdr.list) { 331 331 - if (d->ci->id == domid) { 332 332 - rr.ci = d->ci; 333 333 - mon_event_read(&rr, r, NULL, rdtgrp, 334 334 - &d->ci->shared_cpu_map, evtid, false); 335 335 - goto checkresult; 336 336 - } 337 337 - } 338 338 - ret = -ENOENT; 339 339 - goto out; 340 340 - } else { 341 341 - /* 342 342 - * This file provides data from a single domain. Search 343 343 - * the resource to find the domain with "domid". 344 344 - */ 345 345 - hdr = resctrl_find_domain(&r->mon_domains, domid, NULL); 346 346 - if (!hdr || WARN_ON_ONCE(hdr->type != RESCTRL_MON_DOMAIN)) { 347 347 - ret = -ENOENT; 348 348 - goto out; 349 349 - } 350 350 - d = container_of(hdr, struct rdt_mon_domain, hdr); 351 351 - mon_event_read(&rr, r, d, rdtgrp, &d->hdr.cpu_mask, evtid, false); 352 352 - } 353 353 - 354 354 - checkresult: 355 355 - 356 356 - if (rr.err == -EIO) 357 357 - seq_puts(m, "Error\n"); 358 358 - else if (rr.err == -EINVAL) 359 359 - seq_puts(m, "Unavailable\n"); 360 360 - else 361 361 - seq_printf(m, "%llu\n", rr.val); 362 362 - 363 363 - out: 364 364 - rdtgroup_kn_unlock(of->kn); 365 365 - return ret; 366 455 }

+9 -390

arch/x86/kernel/cpu/resctrl/internal.h

reviewed

··· 3 3 #define _ASM_X86_RESCTRL_INTERNAL_H 4 4 5 5 #include <linux/resctrl.h> 6 6 - #include <linux/sched.h> 7 7 - #include <linux/kernfs.h> 8 8 - #include <linux/fs_context.h> 9 9 - #include <linux/jump_label.h> 10 10 - #include <linux/tick.h> 11 11 - 12 12 - #include <asm/resctrl.h> 13 6 14 7 #define L3_QOS_CDP_ENABLE 0x01ULL 15 8 16 9 #define L2_QOS_CDP_ENABLE 0x01ULL 17 10 18 18 - #define CQM_LIMBOCHECK_INTERVAL 1000 19 19 - 20 11 #define MBM_CNTR_WIDTH_BASE 24 21 21 - #define MBM_OVERFLOW_INTERVAL 1000 22 22 - #define MAX_MBA_BW 100u 12 12 + 23 13 #define MBA_IS_LINEAR 0x4 14 14 + 24 15 #define MBM_CNTR_WIDTH_OFFSET_AMD 20 25 16 26 17 #define RMID_VAL_ERROR BIT_ULL(63) 18 18 + 27 19 #define RMID_VAL_UNAVAIL BIT_ULL(62) 20 20 + 28 21 /* 29 22 * With the above fields in use 62 bits remain in MSR_IA32_QM_CTR for 30 23 * data to be returned. The counter width is discovered from the hardware 31 24 * as an offset from MBM_CNTR_WIDTH_BASE. 32 25 */ 33 26 #define MBM_CNTR_WIDTH_OFFSET_MAX (62 - MBM_CNTR_WIDTH_BASE) 34 34 - 35 35 - /** 36 36 - * cpumask_any_housekeeping() - Choose any CPU in @mask, preferring those that 37 37 - * aren't marked nohz_full 38 38 - * @mask: The mask to pick a CPU from. 39 39 - * @exclude_cpu:The CPU to avoid picking. 40 40 - * 41 41 - * Returns a CPU from @mask, but not @exclude_cpu. If there are housekeeping 42 42 - * CPUs that don't use nohz_full, these are preferred. Pass 43 43 - * RESCTRL_PICK_ANY_CPU to avoid excluding any CPUs. 44 44 - * 45 45 - * When a CPU is excluded, returns >= nr_cpu_ids if no CPUs are available. 46 46 - */ 47 47 - static inline unsigned int 48 48 - cpumask_any_housekeeping(const struct cpumask *mask, int exclude_cpu) 49 49 - { 50 50 - unsigned int cpu, hk_cpu; 51 51 - 52 52 - if (exclude_cpu == RESCTRL_PICK_ANY_CPU) 53 53 - cpu = cpumask_any(mask); 54 54 - else 55 55 - cpu = cpumask_any_but(mask, exclude_cpu); 56 56 - 57 57 - /* Only continue if tick_nohz_full_mask has been initialized. */ 58 58 - if (!tick_nohz_full_enabled()) 59 59 - return cpu; 60 60 - 61 61 - /* If the CPU picked isn't marked nohz_full nothing more needs doing. */ 62 62 - if (cpu < nr_cpu_ids && !tick_nohz_full_cpu(cpu)) 63 63 - return cpu; 64 64 - 65 65 - /* Try to find a CPU that isn't nohz_full to use in preference */ 66 66 - hk_cpu = cpumask_nth_andnot(0, mask, tick_nohz_full_mask); 67 67 - if (hk_cpu == exclude_cpu) 68 68 - hk_cpu = cpumask_nth_andnot(1, mask, tick_nohz_full_mask); 69 69 - 70 70 - if (hk_cpu < nr_cpu_ids) 71 71 - cpu = hk_cpu; 72 72 - 73 73 - return cpu; 74 74 - } 75 75 - 76 76 - struct rdt_fs_context { 77 77 - struct kernfs_fs_context kfc; 78 78 - bool enable_cdpl2; 79 79 - bool enable_cdpl3; 80 80 - bool enable_mba_mbps; 81 81 - bool enable_debug; 82 82 - }; 83 83 - 84 84 - static inline struct rdt_fs_context *rdt_fc2context(struct fs_context *fc) 85 85 - { 86 86 - struct kernfs_fs_context *kfc = fc->fs_private; 87 87 - 88 88 - return container_of(kfc, struct rdt_fs_context, kfc); 89 89 - } 90 90 - 91 91 - /** 92 92 - * struct mon_evt - Entry in the event list of a resource 93 93 - * @evtid: event id 94 94 - * @name: name of the event 95 95 - * @configurable: true if the event is configurable 96 96 - * @list: entry in &rdt_resource->evt_list 97 97 - */ 98 98 - struct mon_evt { 99 99 - enum resctrl_event_id evtid; 100 100 - char *name; 101 101 - bool configurable; 102 102 - struct list_head list; 103 103 - }; 104 104 - 105 105 - /** 106 106 - * union mon_data_bits - Monitoring details for each event file. 107 107 - * @priv: Used to store monitoring event data in @u 108 108 - * as kernfs private data. 109 109 - * @u.rid: Resource id associated with the event file. 110 110 - * @u.evtid: Event id associated with the event file. 111 111 - * @u.sum: Set when event must be summed across multiple 112 112 - * domains. 113 113 - * @u.domid: When @u.sum is zero this is the domain to which 114 114 - * the event file belongs. When @sum is one this 115 115 - * is the id of the L3 cache that all domains to be 116 116 - * summed share. 117 117 - * @u: Name of the bit fields struct. 118 118 - */ 119 119 - union mon_data_bits { 120 120 - void *priv; 121 121 - struct { 122 122 - unsigned int rid : 10; 123 123 - enum resctrl_event_id evtid : 7; 124 124 - unsigned int sum : 1; 125 125 - unsigned int domid : 14; 126 126 - } u; 127 127 - }; 128 128 - 129 129 - /** 130 130 - * struct rmid_read - Data passed across smp_call*() to read event count. 131 131 - * @rgrp: Resource group for which the counter is being read. If it is a parent 132 132 - * resource group then its event count is summed with the count from all 133 133 - * its child resource groups. 134 134 - * @r: Resource describing the properties of the event being read. 135 135 - * @d: Domain that the counter should be read from. If NULL then sum all 136 136 - * domains in @r sharing L3 @ci.id 137 137 - * @evtid: Which monitor event to read. 138 138 - * @first: Initialize MBM counter when true. 139 139 - * @ci: Cacheinfo for L3. Only set when @d is NULL. Used when summing domains. 140 140 - * @err: Error encountered when reading counter. 141 141 - * @val: Returned value of event counter. If @rgrp is a parent resource group, 142 142 - * @val includes the sum of event counts from its child resource groups. 143 143 - * If @d is NULL, @val includes the sum of all domains in @r sharing @ci.id, 144 144 - * (summed across child resource groups if @rgrp is a parent resource group). 145 145 - * @arch_mon_ctx: Hardware monitor allocated for this read request (MPAM only). 146 146 - */ 147 147 - struct rmid_read { 148 148 - struct rdtgroup *rgrp; 149 149 - struct rdt_resource *r; 150 150 - struct rdt_mon_domain *d; 151 151 - enum resctrl_event_id evtid; 152 152 - bool first; 153 153 - struct cacheinfo *ci; 154 154 - int err; 155 155 - u64 val; 156 156 - void *arch_mon_ctx; 157 157 - }; 158 158 - 159 159 - extern struct list_head resctrl_schema_all; 160 160 - extern bool resctrl_mounted; 161 161 - 162 162 - enum rdt_group_type { 163 163 - RDTCTRL_GROUP = 0, 164 164 - RDTMON_GROUP, 165 165 - RDT_NUM_GROUP, 166 166 - }; 167 167 - 168 168 - /** 169 169 - * enum rdtgrp_mode - Mode of a RDT resource group 170 170 - * @RDT_MODE_SHAREABLE: This resource group allows sharing of its allocations 171 171 - * @RDT_MODE_EXCLUSIVE: No sharing of this resource group's allocations allowed 172 172 - * @RDT_MODE_PSEUDO_LOCKSETUP: Resource group will be used for Pseudo-Locking 173 173 - * @RDT_MODE_PSEUDO_LOCKED: No sharing of this resource group's allocations 174 174 - * allowed AND the allocations are Cache Pseudo-Locked 175 175 - * @RDT_NUM_MODES: Total number of modes 176 176 - * 177 177 - * The mode of a resource group enables control over the allowed overlap 178 178 - * between allocations associated with different resource groups (classes 179 179 - * of service). User is able to modify the mode of a resource group by 180 180 - * writing to the "mode" resctrl file associated with the resource group. 181 181 - * 182 182 - * The "shareable", "exclusive", and "pseudo-locksetup" modes are set by 183 183 - * writing the appropriate text to the "mode" file. A resource group enters 184 184 - * "pseudo-locked" mode after the schemata is written while the resource 185 185 - * group is in "pseudo-locksetup" mode. 186 186 - */ 187 187 - enum rdtgrp_mode { 188 188 - RDT_MODE_SHAREABLE = 0, 189 189 - RDT_MODE_EXCLUSIVE, 190 190 - RDT_MODE_PSEUDO_LOCKSETUP, 191 191 - RDT_MODE_PSEUDO_LOCKED, 192 192 - 193 193 - /* Must be last */ 194 194 - RDT_NUM_MODES, 195 195 - }; 196 196 - 197 197 - /** 198 198 - * struct mongroup - store mon group's data in resctrl fs. 199 199 - * @mon_data_kn: kernfs node for the mon_data directory 200 200 - * @parent: parent rdtgrp 201 201 - * @crdtgrp_list: child rdtgroup node list 202 202 - * @rmid: rmid for this rdtgroup 203 203 - */ 204 204 - struct mongroup { 205 205 - struct kernfs_node *mon_data_kn; 206 206 - struct rdtgroup *parent; 207 207 - struct list_head crdtgrp_list; 208 208 - u32 rmid; 209 209 - }; 210 210 - 211 211 - /** 212 212 - * struct rdtgroup - store rdtgroup's data in resctrl file system. 213 213 - * @kn: kernfs node 214 214 - * @rdtgroup_list: linked list for all rdtgroups 215 215 - * @closid: closid for this rdtgroup 216 216 - * @cpu_mask: CPUs assigned to this rdtgroup 217 217 - * @flags: status bits 218 218 - * @waitcount: how many cpus expect to find this 219 219 - * group when they acquire rdtgroup_mutex 220 220 - * @type: indicates type of this rdtgroup - either 221 221 - * monitor only or ctrl_mon group 222 222 - * @mon: mongroup related data 223 223 - * @mode: mode of resource group 224 224 - * @mba_mbps_event: input monitoring event id when mba_sc is enabled 225 225 - * @plr: pseudo-locked region 226 226 - */ 227 227 - struct rdtgroup { 228 228 - struct kernfs_node *kn; 229 229 - struct list_head rdtgroup_list; 230 230 - u32 closid; 231 231 - struct cpumask cpu_mask; 232 232 - int flags; 233 233 - atomic_t waitcount; 234 234 - enum rdt_group_type type; 235 235 - struct mongroup mon; 236 236 - enum rdtgrp_mode mode; 237 237 - enum resctrl_event_id mba_mbps_event; 238 238 - struct pseudo_lock_region *plr; 239 239 - }; 240 240 - 241 241 - /* rdtgroup.flags */ 242 242 - #define RDT_DELETED 1 243 243 - 244 244 - /* rftype.flags */ 245 245 - #define RFTYPE_FLAGS_CPUS_LIST 1 246 246 - 247 247 - /* 248 248 - * Define the file type flags for base and info directories. 249 249 - */ 250 250 - #define RFTYPE_INFO BIT(0) 251 251 - #define RFTYPE_BASE BIT(1) 252 252 - #define RFTYPE_CTRL BIT(4) 253 253 - #define RFTYPE_MON BIT(5) 254 254 - #define RFTYPE_TOP BIT(6) 255 255 - #define RFTYPE_RES_CACHE BIT(8) 256 256 - #define RFTYPE_RES_MB BIT(9) 257 257 - #define RFTYPE_DEBUG BIT(10) 258 258 - #define RFTYPE_CTRL_INFO (RFTYPE_INFO | RFTYPE_CTRL) 259 259 - #define RFTYPE_MON_INFO (RFTYPE_INFO | RFTYPE_MON) 260 260 - #define RFTYPE_TOP_INFO (RFTYPE_INFO | RFTYPE_TOP) 261 261 - #define RFTYPE_CTRL_BASE (RFTYPE_BASE | RFTYPE_CTRL) 262 262 - #define RFTYPE_MON_BASE (RFTYPE_BASE | RFTYPE_MON) 263 263 - 264 264 - /* List of all resource groups */ 265 265 - extern struct list_head rdt_all_groups; 266 266 - 267 267 - extern int max_name_width; 268 268 - 269 269 - /** 270 270 - * struct rftype - describe each file in the resctrl file system 271 271 - * @name: File name 272 272 - * @mode: Access mode 273 273 - * @kf_ops: File operations 274 274 - * @flags: File specific RFTYPE_FLAGS_* flags 275 275 - * @fflags: File specific RFTYPE_* flags 276 276 - * @seq_show: Show content of the file 277 277 - * @write: Write to the file 278 278 - */ 279 279 - struct rftype { 280 280 - char *name; 281 281 - umode_t mode; 282 282 - const struct kernfs_ops *kf_ops; 283 283 - unsigned long flags; 284 284 - unsigned long fflags; 285 285 - 286 286 - int (*seq_show)(struct kernfs_open_file *of, 287 287 - struct seq_file *sf, void *v); 288 288 - /* 289 289 - * write() is the generic write callback which maps directly to 290 290 - * kernfs write operation and overrides all other operations. 291 291 - * Maximum write size is determined by ->max_write_len. 292 292 - */ 293 293 - ssize_t (*write)(struct kernfs_open_file *of, 294 294 - char *buf, size_t nbytes, loff_t off); 295 295 - }; 296 296 - 297 297 - /** 298 298 - * struct mbm_state - status for each MBM counter in each domain 299 299 - * @prev_bw_bytes: Previous bytes value read for bandwidth calculation 300 300 - * @prev_bw: The most recent bandwidth in MBps 301 301 - */ 302 302 - struct mbm_state { 303 303 - u64 prev_bw_bytes; 304 304 - u32 prev_bw; 305 305 - }; 306 27 307 28 /** 308 29 * struct arch_mbm_state - values used to compute resctrl_arch_rmid_read()s ··· 122 401 return container_of(r, struct rdt_hw_resource, r_resctrl); 123 402 } 124 403 125 125 - extern struct mutex rdtgroup_mutex; 126 126 - 127 127 - static inline const char *rdt_kn_name(const struct kernfs_node *kn) 128 128 - { 129 129 - return rcu_dereference_check(kn->name, lockdep_is_held(&rdtgroup_mutex)); 130 130 - } 131 131 - 132 404 extern struct rdt_hw_resource rdt_resources_all[]; 133 133 - extern struct rdtgroup rdtgroup_default; 134 134 - extern struct dentry *debugfs_resctrl; 135 135 - extern enum resctrl_event_id mba_mbps_default_event; 136 136 - 137 137 - static inline bool resctrl_arch_get_cdp_enabled(enum resctrl_res_level l) 138 138 - { 139 139 - return rdt_resources_all[l].cdp_enabled; 140 140 - } 141 141 - 142 142 - int resctrl_arch_set_cdp_enabled(enum resctrl_res_level l, bool enable); 143 405 144 406 void arch_mon_domain_online(struct rdt_resource *r, struct rdt_mon_domain *d); 145 407 ··· 159 455 unsigned int full; 160 456 }; 161 457 162 162 - void rdt_last_cmd_clear(void); 163 163 - void rdt_last_cmd_puts(const char *s); 164 164 - __printf(1, 2) 165 165 - void rdt_last_cmd_printf(const char *fmt, ...); 166 166 - 167 458 void rdt_ctrl_update(void *arg); 168 168 - struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn); 169 169 - void rdtgroup_kn_unlock(struct kernfs_node *kn); 170 170 - int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name); 171 171 - int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, 172 172 - umode_t mask); 173 173 - ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of, 174 174 - char *buf, size_t nbytes, loff_t off); 175 175 - int rdtgroup_schemata_show(struct kernfs_open_file *of, 176 176 - struct seq_file *s, void *v); 177 177 - ssize_t rdtgroup_mba_mbps_event_write(struct kernfs_open_file *of, 178 178 - char *buf, size_t nbytes, loff_t off); 179 179 - int rdtgroup_mba_mbps_event_show(struct kernfs_open_file *of, 180 180 - struct seq_file *s, void *v); 181 181 - bool rdtgroup_cbm_overlaps(struct resctrl_schema *s, struct rdt_ctrl_domain *d, 182 182 - unsigned long cbm, int closid, bool exclusive); 183 183 - unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, struct rdt_ctrl_domain *d, 184 184 - unsigned long cbm); 185 185 - enum rdtgrp_mode rdtgroup_mode_by_closid(int closid); 186 186 - int rdtgroup_tasks_assigned(struct rdtgroup *r); 187 187 - int closids_supported(void); 188 188 - void closid_free(int closid); 189 189 - int alloc_rmid(u32 closid); 190 190 - void free_rmid(u32 closid, u32 rmid); 459 459 + 191 460 int rdt_get_mon_l3_config(struct rdt_resource *r); 192 192 - void resctrl_mon_resource_exit(void); 193 193 - bool __init rdt_cpu_has(int flag); 194 194 - void mon_event_count(void *info); 195 195 - int rdtgroup_mondata_show(struct seq_file *m, void *arg); 196 196 - void mon_event_read(struct rmid_read *rr, struct rdt_resource *r, 197 197 - struct rdt_mon_domain *d, struct rdtgroup *rdtgrp, 198 198 - cpumask_t *cpumask, int evtid, int first); 199 199 - int __init resctrl_mon_resource_init(void); 200 200 - void mbm_setup_overflow_handler(struct rdt_mon_domain *dom, 201 201 - unsigned long delay_ms, 202 202 - int exclude_cpu); 203 203 - void mbm_handle_overflow(struct work_struct *work); 461 461 + 462 462 + bool rdt_cpu_has(int flag); 463 463 + 204 464 void __init intel_rdt_mbm_apply_quirk(void); 205 205 - bool is_mba_sc(struct rdt_resource *r); 206 206 - void cqm_setup_limbo_handler(struct rdt_mon_domain *dom, unsigned long delay_ms, 207 207 - int exclude_cpu); 208 208 - void cqm_handle_limbo(struct work_struct *work); 209 209 - bool has_busy_rmid(struct rdt_mon_domain *d); 210 210 - void __check_limbo(struct rdt_mon_domain *d, bool force_free); 465 465 + 211 466 void rdt_domain_reconfigure_cdp(struct rdt_resource *r); 212 212 - void resctrl_file_fflags_init(const char *config, unsigned long fflags); 213 213 - void rdt_staged_configs_clear(void); 214 214 - bool closid_allocated(unsigned int closid); 215 215 - int resctrl_find_cleanest_closid(void); 216 216 - 217 217 - #ifdef CONFIG_RESCTRL_FS_PSEUDO_LOCK 218 218 - int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp); 219 219 - int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp); 220 220 - bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_ctrl_domain *d, unsigned long cbm); 221 221 - bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_ctrl_domain *d); 222 222 - int rdt_pseudo_lock_init(void); 223 223 - void rdt_pseudo_lock_release(void); 224 224 - int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp); 225 225 - void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp); 226 226 - #else 227 227 - static inline int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp) 228 228 - { 229 229 - return -EOPNOTSUPP; 230 230 - } 231 231 - 232 232 - static inline int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp) 233 233 - { 234 234 - return -EOPNOTSUPP; 235 235 - } 236 236 - 237 237 - static inline bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_ctrl_domain *d, unsigned long cbm) 238 238 - { 239 239 - return false; 240 240 - } 241 241 - 242 242 - static inline bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_ctrl_domain *d) 243 243 - { 244 244 - return false; 245 245 - } 246 246 - 247 247 - static inline int rdt_pseudo_lock_init(void) { return 0; } 248 248 - static inline void rdt_pseudo_lock_release(void) { } 249 249 - static inline int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp) 250 250 - { 251 251 - return -EOPNOTSUPP; 252 252 - } 253 253 - 254 254 - static inline void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp) { } 255 255 - #endif /* CONFIG_RESCTRL_FS_PSEUDO_LOCK */ 256 467 257 468 #endif /* _ASM_X86_RESCTRL_INTERNAL_H */

+7 -911

arch/x86/kernel/cpu/resctrl/monitor.c

reviewed

··· 18 18 #define pr_fmt(fmt) "resctrl: " fmt 19 19 20 20 #include <linux/cpu.h> 21 21 - #include <linux/module.h> 22 22 - #include <linux/sizes.h> 23 23 - #include <linux/slab.h> 21 21 + #include <linux/resctrl.h> 24 22 25 23 #include <asm/cpu_device_id.h> 26 24 #include <asm/msr.h> 27 27 - #include <asm/resctrl.h> 28 25 29 26 #include "internal.h" 30 30 - #include "trace.h" 31 31 - 32 32 - /** 33 33 - * struct rmid_entry - dirty tracking for all RMID. 34 34 - * @closid: The CLOSID for this entry. 35 35 - * @rmid: The RMID for this entry. 36 36 - * @busy: The number of domains with cached data using this RMID. 37 37 - * @list: Member of the rmid_free_lru list when busy == 0. 38 38 - * 39 39 - * Depending on the architecture the correct monitor is accessed using 40 40 - * both @closid and @rmid, or @rmid only. 41 41 - * 42 42 - * Take the rdtgroup_mutex when accessing. 43 43 - */ 44 44 - struct rmid_entry { 45 45 - u32 closid; 46 46 - u32 rmid; 47 47 - int busy; 48 48 - struct list_head list; 49 49 - }; 50 50 - 51 51 - /* 52 52 - * @rmid_free_lru - A least recently used list of free RMIDs 53 53 - * These RMIDs are guaranteed to have an occupancy less than the 54 54 - * threshold occupancy 55 55 - */ 56 56 - static LIST_HEAD(rmid_free_lru); 57 57 - 58 58 - /* 59 59 - * @closid_num_dirty_rmid The number of dirty RMID each CLOSID has. 60 60 - * Only allocated when CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID is defined. 61 61 - * Indexed by CLOSID. Protected by rdtgroup_mutex. 62 62 - */ 63 63 - static u32 *closid_num_dirty_rmid; 64 64 - 65 65 - /* 66 66 - * @rmid_limbo_count - count of currently unused but (potentially) 67 67 - * dirty RMIDs. 68 68 - * This counts RMIDs that no one is currently using but that 69 69 - * may have a occupancy value > resctrl_rmid_realloc_threshold. User can 70 70 - * change the threshold occupancy value. 71 71 - */ 72 72 - static unsigned int rmid_limbo_count; 73 73 - 74 74 - /* 75 75 - * @rmid_entry - The entry in the limbo and free lists. 76 76 - */ 77 77 - static struct rmid_entry *rmid_ptrs; 78 27 79 28 /* 80 29 * Global boolean for rdt_monitor which is true if any ··· 36 87 */ 37 88 unsigned int rdt_mon_features; 38 89 39 39 - /* 40 40 - * This is the threshold cache occupancy in bytes at which we will consider an 41 41 - * RMID available for re-allocation. 42 42 - */ 43 43 - unsigned int resctrl_rmid_realloc_threshold; 44 44 - 45 45 - /* 46 46 - * This is the maximum value for the reallocation threshold, in bytes. 47 47 - */ 48 48 - unsigned int resctrl_rmid_realloc_limit; 49 49 - 50 90 #define CF(cf) ((unsigned long)(1048576 * (cf) + 0.5)) 51 91 52 92 static int snc_nodes_per_l3_cache = 1; 53 93 54 94 /* 55 55 - * The correction factor table is documented in Documentation/arch/x86/resctrl.rst. 95 95 + * The correction factor table is documented in Documentation/filesystems/resctrl.rst. 56 96 * If rmid > rmid threshold, MBM total and local values should be multiplied 57 97 * by the correction factor. 58 98 * ··· 90 152 }; 91 153 92 154 static u32 mbm_cf_rmidthreshold __read_mostly = UINT_MAX; 155 155 + 93 156 static u64 mbm_cf __read_mostly; 94 157 95 158 static inline u64 get_corrected_mbm_count(u32 rmid, unsigned long val) ··· 100 161 val = (val * mbm_cf) >> 20; 101 162 102 163 return val; 103 103 - } 104 104 - 105 105 - /* 106 106 - * x86 and arm64 differ in their handling of monitoring. 107 107 - * x86's RMID are independent numbers, there is only one source of traffic 108 108 - * with an RMID value of '1'. 109 109 - * arm64's PMG extends the PARTID/CLOSID space, there are multiple sources of 110 110 - * traffic with a PMG value of '1', one for each CLOSID, meaning the RMID 111 111 - * value is no longer unique. 112 112 - * To account for this, resctrl uses an index. On x86 this is just the RMID, 113 113 - * on arm64 it encodes the CLOSID and RMID. This gives a unique number. 114 114 - * 115 115 - * The domain's rmid_busy_llc and rmid_ptrs[] are sized by index. The arch code 116 116 - * must accept an attempt to read every index. 117 117 - */ 118 118 - static inline struct rmid_entry *__rmid_entry(u32 idx) 119 119 - { 120 120 - struct rmid_entry *entry; 121 121 - u32 closid, rmid; 122 122 - 123 123 - entry = &rmid_ptrs[idx]; 124 124 - resctrl_arch_rmid_idx_decode(idx, &closid, &rmid); 125 125 - 126 126 - WARN_ON_ONCE(entry->closid != closid); 127 127 - WARN_ON_ONCE(entry->rmid != rmid); 128 128 - 129 129 - return entry; 130 164 } 131 165 132 166 /* ··· 173 261 return &hw_dom->arch_mbm_total[rmid]; 174 262 case QOS_L3_MBM_LOCAL_EVENT_ID: 175 263 return &hw_dom->arch_mbm_local[rmid]; 264 264 + default: 265 265 + /* Never expect to get here */ 266 266 + WARN_ON_ONCE(1); 267 267 + return NULL; 176 268 } 177 177 - 178 178 - /* Never expect to get here */ 179 179 - WARN_ON_ONCE(1); 180 180 - 181 181 - return NULL; 182 269 } 183 270 184 271 void resctrl_arch_reset_rmid(struct rdt_resource *r, struct rdt_mon_domain *d, ··· 256 345 *val = chunks * hw_res->mon_scale; 257 346 258 347 return 0; 259 259 - } 260 260 - 261 261 - static void limbo_release_entry(struct rmid_entry *entry) 262 262 - { 263 263 - lockdep_assert_held(&rdtgroup_mutex); 264 264 - 265 265 - rmid_limbo_count--; 266 266 - list_add_tail(&entry->list, &rmid_free_lru); 267 267 - 268 268 - if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) 269 269 - closid_num_dirty_rmid[entry->closid]--; 270 270 - } 271 271 - 272 272 - /* 273 273 - * Check the RMIDs that are marked as busy for this domain. If the 274 274 - * reported LLC occupancy is below the threshold clear the busy bit and 275 275 - * decrement the count. If the busy count gets to zero on an RMID, we 276 276 - * free the RMID 277 277 - */ 278 278 - void __check_limbo(struct rdt_mon_domain *d, bool force_free) 279 279 - { 280 280 - struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 281 281 - u32 idx_limit = resctrl_arch_system_num_rmid_idx(); 282 282 - struct rmid_entry *entry; 283 283 - u32 idx, cur_idx = 1; 284 284 - void *arch_mon_ctx; 285 285 - bool rmid_dirty; 286 286 - u64 val = 0; 287 287 - 288 288 - arch_mon_ctx = resctrl_arch_mon_ctx_alloc(r, QOS_L3_OCCUP_EVENT_ID); 289 289 - if (IS_ERR(arch_mon_ctx)) { 290 290 - pr_warn_ratelimited("Failed to allocate monitor context: %ld", 291 291 - PTR_ERR(arch_mon_ctx)); 292 292 - return; 293 293 - } 294 294 - 295 295 - /* 296 296 - * Skip RMID 0 and start from RMID 1 and check all the RMIDs that 297 297 - * are marked as busy for occupancy < threshold. If the occupancy 298 298 - * is less than the threshold decrement the busy counter of the 299 299 - * RMID and move it to the free list when the counter reaches 0. 300 300 - */ 301 301 - for (;;) { 302 302 - idx = find_next_bit(d->rmid_busy_llc, idx_limit, cur_idx); 303 303 - if (idx >= idx_limit) 304 304 - break; 305 305 - 306 306 - entry = __rmid_entry(idx); 307 307 - if (resctrl_arch_rmid_read(r, d, entry->closid, entry->rmid, 308 308 - QOS_L3_OCCUP_EVENT_ID, &val, 309 309 - arch_mon_ctx)) { 310 310 - rmid_dirty = true; 311 311 - } else { 312 312 - rmid_dirty = (val >= resctrl_rmid_realloc_threshold); 313 313 - 314 314 - /* 315 315 - * x86's CLOSID and RMID are independent numbers, so the entry's 316 316 - * CLOSID is an empty CLOSID (X86_RESCTRL_EMPTY_CLOSID). On Arm the 317 317 - * RMID (PMG) extends the CLOSID (PARTID) space with bits that aren't 318 318 - * used to select the configuration. It is thus necessary to track both 319 319 - * CLOSID and RMID because there may be dependencies between them 320 320 - * on some architectures. 321 321 - */ 322 322 - trace_mon_llc_occupancy_limbo(entry->closid, entry->rmid, d->hdr.id, val); 323 323 - } 324 324 - 325 325 - if (force_free || !rmid_dirty) { 326 326 - clear_bit(idx, d->rmid_busy_llc); 327 327 - if (!--entry->busy) 328 328 - limbo_release_entry(entry); 329 329 - } 330 330 - cur_idx = idx + 1; 331 331 - } 332 332 - 333 333 - resctrl_arch_mon_ctx_free(r, QOS_L3_OCCUP_EVENT_ID, arch_mon_ctx); 334 334 - } 335 335 - 336 336 - bool has_busy_rmid(struct rdt_mon_domain *d) 337 337 - { 338 338 - u32 idx_limit = resctrl_arch_system_num_rmid_idx(); 339 339 - 340 340 - return find_first_bit(d->rmid_busy_llc, idx_limit) != idx_limit; 341 341 - } 342 342 - 343 343 - static struct rmid_entry *resctrl_find_free_rmid(u32 closid) 344 344 - { 345 345 - struct rmid_entry *itr; 346 346 - u32 itr_idx, cmp_idx; 347 347 - 348 348 - if (list_empty(&rmid_free_lru)) 349 349 - return rmid_limbo_count ? ERR_PTR(-EBUSY) : ERR_PTR(-ENOSPC); 350 350 - 351 351 - list_for_each_entry(itr, &rmid_free_lru, list) { 352 352 - /* 353 353 - * Get the index of this free RMID, and the index it would need 354 354 - * to be if it were used with this CLOSID. 355 355 - * If the CLOSID is irrelevant on this architecture, the two 356 356 - * index values are always the same on every entry and thus the 357 357 - * very first entry will be returned. 358 358 - */ 359 359 - itr_idx = resctrl_arch_rmid_idx_encode(itr->closid, itr->rmid); 360 360 - cmp_idx = resctrl_arch_rmid_idx_encode(closid, itr->rmid); 361 361 - 362 362 - if (itr_idx == cmp_idx) 363 363 - return itr; 364 364 - } 365 365 - 366 366 - return ERR_PTR(-ENOSPC); 367 367 - } 368 368 - 369 369 - /** 370 370 - * resctrl_find_cleanest_closid() - Find a CLOSID where all the associated 371 371 - * RMID are clean, or the CLOSID that has 372 372 - * the most clean RMID. 373 373 - * 374 374 - * MPAM's equivalent of RMID are per-CLOSID, meaning a freshly allocated CLOSID 375 375 - * may not be able to allocate clean RMID. To avoid this the allocator will 376 376 - * choose the CLOSID with the most clean RMID. 377 377 - * 378 378 - * When the CLOSID and RMID are independent numbers, the first free CLOSID will 379 379 - * be returned. 380 380 - */ 381 381 - int resctrl_find_cleanest_closid(void) 382 382 - { 383 383 - u32 cleanest_closid = ~0; 384 384 - int i = 0; 385 385 - 386 386 - lockdep_assert_held(&rdtgroup_mutex); 387 387 - 388 388 - if (!IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) 389 389 - return -EIO; 390 390 - 391 391 - for (i = 0; i < closids_supported(); i++) { 392 392 - int num_dirty; 393 393 - 394 394 - if (closid_allocated(i)) 395 395 - continue; 396 396 - 397 397 - num_dirty = closid_num_dirty_rmid[i]; 398 398 - if (num_dirty == 0) 399 399 - return i; 400 400 - 401 401 - if (cleanest_closid == ~0) 402 402 - cleanest_closid = i; 403 403 - 404 404 - if (num_dirty < closid_num_dirty_rmid[cleanest_closid]) 405 405 - cleanest_closid = i; 406 406 - } 407 407 - 408 408 - if (cleanest_closid == ~0) 409 409 - return -ENOSPC; 410 410 - 411 411 - return cleanest_closid; 412 412 - } 413 413 - 414 414 - /* 415 415 - * For MPAM the RMID value is not unique, and has to be considered with 416 416 - * the CLOSID. The (CLOSID, RMID) pair is allocated on all domains, which 417 417 - * allows all domains to be managed by a single free list. 418 418 - * Each domain also has a rmid_busy_llc to reduce the work of the limbo handler. 419 419 - */ 420 420 - int alloc_rmid(u32 closid) 421 421 - { 422 422 - struct rmid_entry *entry; 423 423 - 424 424 - lockdep_assert_held(&rdtgroup_mutex); 425 425 - 426 426 - entry = resctrl_find_free_rmid(closid); 427 427 - if (IS_ERR(entry)) 428 428 - return PTR_ERR(entry); 429 429 - 430 430 - list_del(&entry->list); 431 431 - return entry->rmid; 432 432 - } 433 433 - 434 434 - static void add_rmid_to_limbo(struct rmid_entry *entry) 435 435 - { 436 436 - struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 437 437 - struct rdt_mon_domain *d; 438 438 - u32 idx; 439 439 - 440 440 - lockdep_assert_held(&rdtgroup_mutex); 441 441 - 442 442 - /* Walking r->domains, ensure it can't race with cpuhp */ 443 443 - lockdep_assert_cpus_held(); 444 444 - 445 445 - idx = resctrl_arch_rmid_idx_encode(entry->closid, entry->rmid); 446 446 - 447 447 - entry->busy = 0; 448 448 - list_for_each_entry(d, &r->mon_domains, hdr.list) { 449 449 - /* 450 450 - * For the first limbo RMID in the domain, 451 451 - * setup up the limbo worker. 452 452 - */ 453 453 - if (!has_busy_rmid(d)) 454 454 - cqm_setup_limbo_handler(d, CQM_LIMBOCHECK_INTERVAL, 455 455 - RESCTRL_PICK_ANY_CPU); 456 456 - set_bit(idx, d->rmid_busy_llc); 457 457 - entry->busy++; 458 458 - } 459 459 - 460 460 - rmid_limbo_count++; 461 461 - if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) 462 462 - closid_num_dirty_rmid[entry->closid]++; 463 463 - } 464 464 - 465 465 - void free_rmid(u32 closid, u32 rmid) 466 466 - { 467 467 - u32 idx = resctrl_arch_rmid_idx_encode(closid, rmid); 468 468 - struct rmid_entry *entry; 469 469 - 470 470 - lockdep_assert_held(&rdtgroup_mutex); 471 471 - 472 472 - /* 473 473 - * Do not allow the default rmid to be free'd. Comparing by index 474 474 - * allows architectures that ignore the closid parameter to avoid an 475 475 - * unnecessary check. 476 476 - */ 477 477 - if (!resctrl_arch_mon_capable() || 478 478 - idx == resctrl_arch_rmid_idx_encode(RESCTRL_RESERVED_CLOSID, 479 479 - RESCTRL_RESERVED_RMID)) 480 480 - return; 481 481 - 482 482 - entry = __rmid_entry(idx); 483 483 - 484 484 - if (resctrl_arch_is_llc_occupancy_enabled()) 485 485 - add_rmid_to_limbo(entry); 486 486 - else 487 487 - list_add_tail(&entry->list, &rmid_free_lru); 488 488 - } 489 489 - 490 490 - static struct mbm_state *get_mbm_state(struct rdt_mon_domain *d, u32 closid, 491 491 - u32 rmid, enum resctrl_event_id evtid) 492 492 - { 493 493 - u32 idx = resctrl_arch_rmid_idx_encode(closid, rmid); 494 494 - 495 495 - switch (evtid) { 496 496 - case QOS_L3_MBM_TOTAL_EVENT_ID: 497 497 - return &d->mbm_total[idx]; 498 498 - case QOS_L3_MBM_LOCAL_EVENT_ID: 499 499 - return &d->mbm_local[idx]; 500 500 - default: 501 501 - return NULL; 502 502 - } 503 503 - } 504 504 - 505 505 - static int __mon_event_count(u32 closid, u32 rmid, struct rmid_read *rr) 506 506 - { 507 507 - int cpu = smp_processor_id(); 508 508 - struct rdt_mon_domain *d; 509 509 - struct mbm_state *m; 510 510 - int err, ret; 511 511 - u64 tval = 0; 512 512 - 513 513 - if (rr->first) { 514 514 - resctrl_arch_reset_rmid(rr->r, rr->d, closid, rmid, rr->evtid); 515 515 - m = get_mbm_state(rr->d, closid, rmid, rr->evtid); 516 516 - if (m) 517 517 - memset(m, 0, sizeof(struct mbm_state)); 518 518 - return 0; 519 519 - } 520 520 - 521 521 - if (rr->d) { 522 522 - /* Reading a single domain, must be on a CPU in that domain. */ 523 523 - if (!cpumask_test_cpu(cpu, &rr->d->hdr.cpu_mask)) 524 524 - return -EINVAL; 525 525 - rr->err = resctrl_arch_rmid_read(rr->r, rr->d, closid, rmid, 526 526 - rr->evtid, &tval, rr->arch_mon_ctx); 527 527 - if (rr->err) 528 528 - return rr->err; 529 529 - 530 530 - rr->val += tval; 531 531 - 532 532 - return 0; 533 533 - } 534 534 - 535 535 - /* Summing domains that share a cache, must be on a CPU for that cache. */ 536 536 - if (!cpumask_test_cpu(cpu, &rr->ci->shared_cpu_map)) 537 537 - return -EINVAL; 538 538 - 539 539 - /* 540 540 - * Legacy files must report the sum of an event across all 541 541 - * domains that share the same L3 cache instance. 542 542 - * Report success if a read from any domain succeeds, -EINVAL 543 543 - * (translated to "Unavailable" for user space) if reading from 544 544 - * all domains fail for any reason. 545 545 - */ 546 546 - ret = -EINVAL; 547 547 - list_for_each_entry(d, &rr->r->mon_domains, hdr.list) { 548 548 - if (d->ci->id != rr->ci->id) 549 549 - continue; 550 550 - err = resctrl_arch_rmid_read(rr->r, d, closid, rmid, 551 551 - rr->evtid, &tval, rr->arch_mon_ctx); 552 552 - if (!err) { 553 553 - rr->val += tval; 554 554 - ret = 0; 555 555 - } 556 556 - } 557 557 - 558 558 - if (ret) 559 559 - rr->err = ret; 560 560 - 561 561 - return ret; 562 562 - } 563 563 - 564 564 - /* 565 565 - * mbm_bw_count() - Update bw count from values previously read by 566 566 - * __mon_event_count(). 567 567 - * @closid: The closid used to identify the cached mbm_state. 568 568 - * @rmid: The rmid used to identify the cached mbm_state. 569 569 - * @rr: The struct rmid_read populated by __mon_event_count(). 570 570 - * 571 571 - * Supporting function to calculate the memory bandwidth 572 572 - * and delta bandwidth in MBps. The chunks value previously read by 573 573 - * __mon_event_count() is compared with the chunks value from the previous 574 574 - * invocation. This must be called once per second to maintain values in MBps. 575 575 - */ 576 576 - static void mbm_bw_count(u32 closid, u32 rmid, struct rmid_read *rr) 577 577 - { 578 578 - u64 cur_bw, bytes, cur_bytes; 579 579 - struct mbm_state *m; 580 580 - 581 581 - m = get_mbm_state(rr->d, closid, rmid, rr->evtid); 582 582 - if (WARN_ON_ONCE(!m)) 583 583 - return; 584 584 - 585 585 - cur_bytes = rr->val; 586 586 - bytes = cur_bytes - m->prev_bw_bytes; 587 587 - m->prev_bw_bytes = cur_bytes; 588 588 - 589 589 - cur_bw = bytes / SZ_1M; 590 590 - 591 591 - m->prev_bw = cur_bw; 592 592 - } 593 593 - 594 594 - /* 595 595 - * This is scheduled by mon_event_read() to read the CQM/MBM counters 596 596 - * on a domain. 597 597 - */ 598 598 - void mon_event_count(void *info) 599 599 - { 600 600 - struct rdtgroup *rdtgrp, *entry; 601 601 - struct rmid_read *rr = info; 602 602 - struct list_head *head; 603 603 - int ret; 604 604 - 605 605 - rdtgrp = rr->rgrp; 606 606 - 607 607 - ret = __mon_event_count(rdtgrp->closid, rdtgrp->mon.rmid, rr); 608 608 - 609 609 - /* 610 610 - * For Ctrl groups read data from child monitor groups and 611 611 - * add them together. Count events which are read successfully. 612 612 - * Discard the rmid_read's reporting errors. 613 613 - */ 614 614 - head = &rdtgrp->mon.crdtgrp_list; 615 615 - 616 616 - if (rdtgrp->type == RDTCTRL_GROUP) { 617 617 - list_for_each_entry(entry, head, mon.crdtgrp_list) { 618 618 - if (__mon_event_count(entry->closid, entry->mon.rmid, 619 619 - rr) == 0) 620 620 - ret = 0; 621 621 - } 622 622 - } 623 623 - 624 624 - /* 625 625 - * __mon_event_count() calls for newly created monitor groups may 626 626 - * report -EINVAL/Unavailable if the monitor hasn't seen any traffic. 627 627 - * Discard error if any of the monitor event reads succeeded. 628 628 - */ 629 629 - if (ret == 0) 630 630 - rr->err = 0; 631 631 - } 632 632 - 633 633 - static struct rdt_ctrl_domain *get_ctrl_domain_from_cpu(int cpu, 634 634 - struct rdt_resource *r) 635 635 - { 636 636 - struct rdt_ctrl_domain *d; 637 637 - 638 638 - lockdep_assert_cpus_held(); 639 639 - 640 640 - list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 641 641 - /* Find the domain that contains this CPU */ 642 642 - if (cpumask_test_cpu(cpu, &d->hdr.cpu_mask)) 643 643 - return d; 644 644 - } 645 645 - 646 646 - return NULL; 647 647 - } 648 648 - 649 649 - /* 650 650 - * Feedback loop for MBA software controller (mba_sc) 651 651 - * 652 652 - * mba_sc is a feedback loop where we periodically read MBM counters and 653 653 - * adjust the bandwidth percentage values via the IA32_MBA_THRTL_MSRs so 654 654 - * that: 655 655 - * 656 656 - * current bandwidth(cur_bw) < user specified bandwidth(user_bw) 657 657 - * 658 658 - * This uses the MBM counters to measure the bandwidth and MBA throttle 659 659 - * MSRs to control the bandwidth for a particular rdtgrp. It builds on the 660 660 - * fact that resctrl rdtgroups have both monitoring and control. 661 661 - * 662 662 - * The frequency of the checks is 1s and we just tag along the MBM overflow 663 663 - * timer. Having 1s interval makes the calculation of bandwidth simpler. 664 664 - * 665 665 - * Although MBA's goal is to restrict the bandwidth to a maximum, there may 666 666 - * be a need to increase the bandwidth to avoid unnecessarily restricting 667 667 - * the L2 <-> L3 traffic. 668 668 - * 669 669 - * Since MBA controls the L2 external bandwidth where as MBM measures the 670 670 - * L3 external bandwidth the following sequence could lead to such a 671 671 - * situation. 672 672 - * 673 673 - * Consider an rdtgroup which had high L3 <-> memory traffic in initial 674 674 - * phases -> mba_sc kicks in and reduced bandwidth percentage values -> but 675 675 - * after some time rdtgroup has mostly L2 <-> L3 traffic. 676 676 - * 677 677 - * In this case we may restrict the rdtgroup's L2 <-> L3 traffic as its 678 678 - * throttle MSRs already have low percentage values. To avoid 679 679 - * unnecessarily restricting such rdtgroups, we also increase the bandwidth. 680 680 - */ 681 681 - static void update_mba_bw(struct rdtgroup *rgrp, struct rdt_mon_domain *dom_mbm) 682 682 - { 683 683 - u32 closid, rmid, cur_msr_val, new_msr_val; 684 684 - struct mbm_state *pmbm_data, *cmbm_data; 685 685 - struct rdt_ctrl_domain *dom_mba; 686 686 - enum resctrl_event_id evt_id; 687 687 - struct rdt_resource *r_mba; 688 688 - struct list_head *head; 689 689 - struct rdtgroup *entry; 690 690 - u32 cur_bw, user_bw; 691 691 - 692 692 - r_mba = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 693 693 - evt_id = rgrp->mba_mbps_event; 694 694 - 695 695 - closid = rgrp->closid; 696 696 - rmid = rgrp->mon.rmid; 697 697 - pmbm_data = get_mbm_state(dom_mbm, closid, rmid, evt_id); 698 698 - if (WARN_ON_ONCE(!pmbm_data)) 699 699 - return; 700 700 - 701 701 - dom_mba = get_ctrl_domain_from_cpu(smp_processor_id(), r_mba); 702 702 - if (!dom_mba) { 703 703 - pr_warn_once("Failure to get domain for MBA update\n"); 704 704 - return; 705 705 - } 706 706 - 707 707 - cur_bw = pmbm_data->prev_bw; 708 708 - user_bw = dom_mba->mbps_val[closid]; 709 709 - 710 710 - /* MBA resource doesn't support CDP */ 711 711 - cur_msr_val = resctrl_arch_get_config(r_mba, dom_mba, closid, CDP_NONE); 712 712 - 713 713 - /* 714 714 - * For Ctrl groups read data from child monitor groups. 715 715 - */ 716 716 - head = &rgrp->mon.crdtgrp_list; 717 717 - list_for_each_entry(entry, head, mon.crdtgrp_list) { 718 718 - cmbm_data = get_mbm_state(dom_mbm, entry->closid, entry->mon.rmid, evt_id); 719 719 - if (WARN_ON_ONCE(!cmbm_data)) 720 720 - return; 721 721 - cur_bw += cmbm_data->prev_bw; 722 722 - } 723 723 - 724 724 - /* 725 725 - * Scale up/down the bandwidth linearly for the ctrl group. The 726 726 - * bandwidth step is the bandwidth granularity specified by the 727 727 - * hardware. 728 728 - * Always increase throttling if current bandwidth is above the 729 729 - * target set by user. 730 730 - * But avoid thrashing up and down on every poll by checking 731 731 - * whether a decrease in throttling is likely to push the group 732 732 - * back over target. E.g. if currently throttling to 30% of bandwidth 733 733 - * on a system with 10% granularity steps, check whether moving to 734 734 - * 40% would go past the limit by multiplying current bandwidth by 735 735 - * "(30 + 10) / 30". 736 736 - */ 737 737 - if (cur_msr_val > r_mba->membw.min_bw && user_bw < cur_bw) { 738 738 - new_msr_val = cur_msr_val - r_mba->membw.bw_gran; 739 739 - } else if (cur_msr_val < MAX_MBA_BW && 740 740 - (user_bw > (cur_bw * (cur_msr_val + r_mba->membw.min_bw) / cur_msr_val))) { 741 741 - new_msr_val = cur_msr_val + r_mba->membw.bw_gran; 742 742 - } else { 743 743 - return; 744 744 - } 745 745 - 746 746 - resctrl_arch_update_one(r_mba, dom_mba, closid, CDP_NONE, new_msr_val); 747 747 - } 748 748 - 749 749 - static void mbm_update_one_event(struct rdt_resource *r, struct rdt_mon_domain *d, 750 750 - u32 closid, u32 rmid, enum resctrl_event_id evtid) 751 751 - { 752 752 - struct rmid_read rr = {0}; 753 753 - 754 754 - rr.r = r; 755 755 - rr.d = d; 756 756 - rr.evtid = evtid; 757 757 - rr.arch_mon_ctx = resctrl_arch_mon_ctx_alloc(rr.r, rr.evtid); 758 758 - if (IS_ERR(rr.arch_mon_ctx)) { 759 759 - pr_warn_ratelimited("Failed to allocate monitor context: %ld", 760 760 - PTR_ERR(rr.arch_mon_ctx)); 761 761 - return; 762 762 - } 763 763 - 764 764 - __mon_event_count(closid, rmid, &rr); 765 765 - 766 766 - /* 767 767 - * If the software controller is enabled, compute the 768 768 - * bandwidth for this event id. 769 769 - */ 770 770 - if (is_mba_sc(NULL)) 771 771 - mbm_bw_count(closid, rmid, &rr); 772 772 - 773 773 - resctrl_arch_mon_ctx_free(rr.r, rr.evtid, rr.arch_mon_ctx); 774 774 - } 775 775 - 776 776 - static void mbm_update(struct rdt_resource *r, struct rdt_mon_domain *d, 777 777 - u32 closid, u32 rmid) 778 778 - { 779 779 - /* 780 780 - * This is protected from concurrent reads from user as both 781 781 - * the user and overflow handler hold the global mutex. 782 782 - */ 783 783 - if (resctrl_arch_is_mbm_total_enabled()) 784 784 - mbm_update_one_event(r, d, closid, rmid, QOS_L3_MBM_TOTAL_EVENT_ID); 785 785 - 786 786 - if (resctrl_arch_is_mbm_local_enabled()) 787 787 - mbm_update_one_event(r, d, closid, rmid, QOS_L3_MBM_LOCAL_EVENT_ID); 788 788 - } 789 789 - 790 790 - /* 791 791 - * Handler to scan the limbo list and move the RMIDs 792 792 - * to free list whose occupancy < threshold_occupancy. 793 793 - */ 794 794 - void cqm_handle_limbo(struct work_struct *work) 795 795 - { 796 796 - unsigned long delay = msecs_to_jiffies(CQM_LIMBOCHECK_INTERVAL); 797 797 - struct rdt_mon_domain *d; 798 798 - 799 799 - cpus_read_lock(); 800 800 - mutex_lock(&rdtgroup_mutex); 801 801 - 802 802 - d = container_of(work, struct rdt_mon_domain, cqm_limbo.work); 803 803 - 804 804 - __check_limbo(d, false); 805 805 - 806 806 - if (has_busy_rmid(d)) { 807 807 - d->cqm_work_cpu = cpumask_any_housekeeping(&d->hdr.cpu_mask, 808 808 - RESCTRL_PICK_ANY_CPU); 809 809 - schedule_delayed_work_on(d->cqm_work_cpu, &d->cqm_limbo, 810 810 - delay); 811 811 - } 812 812 - 813 813 - mutex_unlock(&rdtgroup_mutex); 814 814 - cpus_read_unlock(); 815 815 - } 816 816 - 817 817 - /** 818 818 - * cqm_setup_limbo_handler() - Schedule the limbo handler to run for this 819 819 - * domain. 820 820 - * @dom: The domain the limbo handler should run for. 821 821 - * @delay_ms: How far in the future the handler should run. 822 822 - * @exclude_cpu: Which CPU the handler should not run on, 823 823 - * RESCTRL_PICK_ANY_CPU to pick any CPU. 824 824 - */ 825 825 - void cqm_setup_limbo_handler(struct rdt_mon_domain *dom, unsigned long delay_ms, 826 826 - int exclude_cpu) 827 827 - { 828 828 - unsigned long delay = msecs_to_jiffies(delay_ms); 829 829 - int cpu; 830 830 - 831 831 - cpu = cpumask_any_housekeeping(&dom->hdr.cpu_mask, exclude_cpu); 832 832 - dom->cqm_work_cpu = cpu; 833 833 - 834 834 - if (cpu < nr_cpu_ids) 835 835 - schedule_delayed_work_on(cpu, &dom->cqm_limbo, delay); 836 836 - } 837 837 - 838 838 - void mbm_handle_overflow(struct work_struct *work) 839 839 - { 840 840 - unsigned long delay = msecs_to_jiffies(MBM_OVERFLOW_INTERVAL); 841 841 - struct rdtgroup *prgrp, *crgrp; 842 842 - struct rdt_mon_domain *d; 843 843 - struct list_head *head; 844 844 - struct rdt_resource *r; 845 845 - 846 846 - cpus_read_lock(); 847 847 - mutex_lock(&rdtgroup_mutex); 848 848 - 849 849 - /* 850 850 - * If the filesystem has been unmounted this work no longer needs to 851 851 - * run. 852 852 - */ 853 853 - if (!resctrl_mounted || !resctrl_arch_mon_capable()) 854 854 - goto out_unlock; 855 855 - 856 856 - r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 857 857 - d = container_of(work, struct rdt_mon_domain, mbm_over.work); 858 858 - 859 859 - list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 860 860 - mbm_update(r, d, prgrp->closid, prgrp->mon.rmid); 861 861 - 862 862 - head = &prgrp->mon.crdtgrp_list; 863 863 - list_for_each_entry(crgrp, head, mon.crdtgrp_list) 864 864 - mbm_update(r, d, crgrp->closid, crgrp->mon.rmid); 865 865 - 866 866 - if (is_mba_sc(NULL)) 867 867 - update_mba_bw(prgrp, d); 868 868 - } 869 869 - 870 870 - /* 871 871 - * Re-check for housekeeping CPUs. This allows the overflow handler to 872 872 - * move off a nohz_full CPU quickly. 873 873 - */ 874 874 - d->mbm_work_cpu = cpumask_any_housekeeping(&d->hdr.cpu_mask, 875 875 - RESCTRL_PICK_ANY_CPU); 876 876 - schedule_delayed_work_on(d->mbm_work_cpu, &d->mbm_over, delay); 877 877 - 878 878 - out_unlock: 879 879 - mutex_unlock(&rdtgroup_mutex); 880 880 - cpus_read_unlock(); 881 881 - } 882 882 - 883 883 - /** 884 884 - * mbm_setup_overflow_handler() - Schedule the overflow handler to run for this 885 885 - * domain. 886 886 - * @dom: The domain the overflow handler should run for. 887 887 - * @delay_ms: How far in the future the handler should run. 888 888 - * @exclude_cpu: Which CPU the handler should not run on, 889 889 - * RESCTRL_PICK_ANY_CPU to pick any CPU. 890 890 - */ 891 891 - void mbm_setup_overflow_handler(struct rdt_mon_domain *dom, unsigned long delay_ms, 892 892 - int exclude_cpu) 893 893 - { 894 894 - unsigned long delay = msecs_to_jiffies(delay_ms); 895 895 - int cpu; 896 896 - 897 897 - /* 898 898 - * When a domain comes online there is no guarantee the filesystem is 899 899 - * mounted. If not, there is no need to catch counter overflow. 900 900 - */ 901 901 - if (!resctrl_mounted || !resctrl_arch_mon_capable()) 902 902 - return; 903 903 - cpu = cpumask_any_housekeeping(&dom->hdr.cpu_mask, exclude_cpu); 904 904 - dom->mbm_work_cpu = cpu; 905 905 - 906 906 - if (cpu < nr_cpu_ids) 907 907 - schedule_delayed_work_on(cpu, &dom->mbm_over, delay); 908 908 - } 909 909 - 910 910 - static int dom_data_init(struct rdt_resource *r) 911 911 - { 912 912 - u32 idx_limit = resctrl_arch_system_num_rmid_idx(); 913 913 - u32 num_closid = resctrl_arch_get_num_closid(r); 914 914 - struct rmid_entry *entry = NULL; 915 915 - int err = 0, i; 916 916 - u32 idx; 917 917 - 918 918 - mutex_lock(&rdtgroup_mutex); 919 919 - if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) { 920 920 - u32 *tmp; 921 921 - 922 922 - /* 923 923 - * If the architecture hasn't provided a sanitised value here, 924 924 - * this may result in larger arrays than necessary. Resctrl will 925 925 - * use a smaller system wide value based on the resources in 926 926 - * use. 927 927 - */ 928 928 - tmp = kcalloc(num_closid, sizeof(*tmp), GFP_KERNEL); 929 929 - if (!tmp) { 930 930 - err = -ENOMEM; 931 931 - goto out_unlock; 932 932 - } 933 933 - 934 934 - closid_num_dirty_rmid = tmp; 935 935 - } 936 936 - 937 937 - rmid_ptrs = kcalloc(idx_limit, sizeof(struct rmid_entry), GFP_KERNEL); 938 938 - if (!rmid_ptrs) { 939 939 - if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) { 940 940 - kfree(closid_num_dirty_rmid); 941 941 - closid_num_dirty_rmid = NULL; 942 942 - } 943 943 - err = -ENOMEM; 944 944 - goto out_unlock; 945 945 - } 946 946 - 947 947 - for (i = 0; i < idx_limit; i++) { 948 948 - entry = &rmid_ptrs[i]; 949 949 - INIT_LIST_HEAD(&entry->list); 950 950 - 951 951 - resctrl_arch_rmid_idx_decode(i, &entry->closid, &entry->rmid); 952 952 - list_add_tail(&entry->list, &rmid_free_lru); 953 953 - } 954 954 - 955 955 - /* 956 956 - * RESCTRL_RESERVED_CLOSID and RESCTRL_RESERVED_RMID are special and 957 957 - * are always allocated. These are used for the rdtgroup_default 958 958 - * control group, which will be setup later in resctrl_init(). 959 959 - */ 960 960 - idx = resctrl_arch_rmid_idx_encode(RESCTRL_RESERVED_CLOSID, 961 961 - RESCTRL_RESERVED_RMID); 962 962 - entry = __rmid_entry(idx); 963 963 - list_del(&entry->list); 964 964 - 965 965 - out_unlock: 966 966 - mutex_unlock(&rdtgroup_mutex); 967 967 - 968 968 - return err; 969 969 - } 970 970 - 971 971 - static void dom_data_exit(struct rdt_resource *r) 972 972 - { 973 973 - mutex_lock(&rdtgroup_mutex); 974 974 - 975 975 - if (!r->mon_capable) 976 976 - goto out_unlock; 977 977 - 978 978 - if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) { 979 979 - kfree(closid_num_dirty_rmid); 980 980 - closid_num_dirty_rmid = NULL; 981 981 - } 982 982 - 983 983 - kfree(rmid_ptrs); 984 984 - rmid_ptrs = NULL; 985 985 - 986 986 - out_unlock: 987 987 - mutex_unlock(&rdtgroup_mutex); 988 988 - } 989 989 - 990 990 - static struct mon_evt llc_occupancy_event = { 991 991 - .name = "llc_occupancy", 992 992 - .evtid = QOS_L3_OCCUP_EVENT_ID, 993 993 - }; 994 994 - 995 995 - static struct mon_evt mbm_total_event = { 996 996 - .name = "mbm_total_bytes", 997 997 - .evtid = QOS_L3_MBM_TOTAL_EVENT_ID, 998 998 - }; 999 999 - 1000 1000 - static struct mon_evt mbm_local_event = { 1001 1001 - .name = "mbm_local_bytes", 1002 1002 - .evtid = QOS_L3_MBM_LOCAL_EVENT_ID, 1003 1003 - }; 1004 1004 - 1005 1005 - /* 1006 1006 - * Initialize the event list for the resource. 1007 1007 - * 1008 1008 - * Note that MBM events are also part of RDT_RESOURCE_L3 resource 1009 1009 - * because as per the SDM the total and local memory bandwidth 1010 1010 - * are enumerated as part of L3 monitoring. 1011 1011 - */ 1012 1012 - static void l3_mon_evt_init(struct rdt_resource *r) 1013 1013 - { 1014 1014 - INIT_LIST_HEAD(&r->evt_list); 1015 1015 - 1016 1016 - if (resctrl_arch_is_llc_occupancy_enabled()) 1017 1017 - list_add_tail(&llc_occupancy_event.list, &r->evt_list); 1018 1018 - if (resctrl_arch_is_mbm_total_enabled()) 1019 1019 - list_add_tail(&mbm_total_event.list, &r->evt_list); 1020 1020 - if (resctrl_arch_is_mbm_local_enabled()) 1021 1021 - list_add_tail(&mbm_local_event.list, &r->evt_list); 1022 348 } 1023 349 1024 350 /* ··· 341 1193 return ret; 342 1194 } 343 1195 344 344 - /** 345 345 - * resctrl_mon_resource_init() - Initialise global monitoring structures. 346 346 - * 347 347 - * Allocate and initialise global monitor resources that do not belong to a 348 348 - * specific domain. i.e. the rmid_ptrs[] used for the limbo and free lists. 349 349 - * Called once during boot after the struct rdt_resource's have been configured 350 350 - * but before the filesystem is mounted. 351 351 - * Resctrl's cpuhp callbacks may be called before this point to bring a domain 352 352 - * online. 353 353 - * 354 354 - * Returns 0 for success, or -ENOMEM. 355 355 - */ 356 356 - int __init resctrl_mon_resource_init(void) 357 357 - { 358 358 - struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 359 359 - int ret; 360 360 - 361 361 - if (!r->mon_capable) 362 362 - return 0; 363 363 - 364 364 - ret = dom_data_init(r); 365 365 - if (ret) 366 366 - return ret; 367 367 - 368 368 - l3_mon_evt_init(r); 369 369 - 370 370 - if (resctrl_arch_is_evt_configurable(QOS_L3_MBM_TOTAL_EVENT_ID)) { 371 371 - mbm_total_event.configurable = true; 372 372 - resctrl_file_fflags_init("mbm_total_bytes_config", 373 373 - RFTYPE_MON_INFO | RFTYPE_RES_CACHE); 374 374 - } 375 375 - if (resctrl_arch_is_evt_configurable(QOS_L3_MBM_LOCAL_EVENT_ID)) { 376 376 - mbm_local_event.configurable = true; 377 377 - resctrl_file_fflags_init("mbm_local_bytes_config", 378 378 - RFTYPE_MON_INFO | RFTYPE_RES_CACHE); 379 379 - } 380 380 - 381 381 - if (resctrl_arch_is_mbm_local_enabled()) 382 382 - mba_mbps_default_event = QOS_L3_MBM_LOCAL_EVENT_ID; 383 383 - else if (resctrl_arch_is_mbm_total_enabled()) 384 384 - mba_mbps_default_event = QOS_L3_MBM_TOTAL_EVENT_ID; 385 385 - 386 386 - return 0; 387 387 - } 388 388 - 389 1196 int __init rdt_get_mon_l3_config(struct rdt_resource *r) 390 1197 { 391 1198 unsigned int mbm_offset = boot_cpu_data.x86_cache_mbm_width_offset; ··· 386 1283 r->mon_capable = true; 387 1284 388 1285 return 0; 389 389 - } 390 390 - 391 391 - void resctrl_mon_resource_exit(void) 392 392 - { 393 393 - struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 394 394 - 395 395 - dom_data_exit(r); 396 1286 } 397 1287 398 1288 void __init intel_rdt_mbm_apply_quirk(void)

+4 -1088

arch/x86/kernel/cpu/resctrl/pseudo_lock.c

reviewed

··· 11 11 12 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 14 14 + #include <linux/cacheflush.h> 14 15 #include <linux/cpu.h> 15 15 - #include <linux/cpumask.h> 16 16 - #include <linux/debugfs.h> 17 17 - #include <linux/kthread.h> 18 18 - #include <linux/mman.h> 19 16 #include <linux/perf_event.h> 20 17 #include <linux/pm_qos.h> 21 21 - #include <linux/slab.h> 22 22 - #include <linux/uaccess.h> 18 18 + #include <linux/resctrl.h> 23 19 24 24 - #include <asm/cacheflush.h> 25 20 #include <asm/cpu_device_id.h> 26 26 - #include <asm/resctrl.h> 27 21 #include <asm/perf_event.h> 28 22 #include <asm/msr.h> 29 23 ··· 25 31 #include "internal.h" 26 32 27 33 #define CREATE_TRACE_POINTS 28 28 - #include "trace.h" 34 34 + 35 35 + #include "pseudo_lock_trace.h" 29 36 30 37 /* 31 38 * The bits needed to disable hardware prefetching varies based on the 32 39 * platform. During initialization we will discover which bits to use. 33 40 */ 34 41 static u64 prefetch_disable_bits; 35 35 - 36 36 - /* 37 37 - * Major number assigned to and shared by all devices exposing 38 38 - * pseudo-locked regions. 39 39 - */ 40 40 - static unsigned int pseudo_lock_major; 41 41 - static unsigned long pseudo_lock_minor_avail = GENMASK(MINORBITS, 0); 42 42 - 43 43 - static char *pseudo_lock_devnode(const struct device *dev, umode_t *mode) 44 44 - { 45 45 - const struct rdtgroup *rdtgrp; 46 46 - 47 47 - rdtgrp = dev_get_drvdata(dev); 48 48 - if (mode) 49 49 - *mode = 0600; 50 50 - guard(mutex)(&rdtgroup_mutex); 51 51 - return kasprintf(GFP_KERNEL, "pseudo_lock/%s", rdt_kn_name(rdtgrp->kn)); 52 52 - } 53 53 - 54 54 - static const struct class pseudo_lock_class = { 55 55 - .name = "pseudo_lock", 56 56 - .devnode = pseudo_lock_devnode, 57 57 - }; 58 42 59 43 /** 60 44 * resctrl_arch_get_prefetch_disable_bits - prefetch disable bits of supported ··· 92 120 } 93 121 94 122 return prefetch_disable_bits; 95 95 - } 96 96 - 97 97 - /** 98 98 - * pseudo_lock_minor_get - Obtain available minor number 99 99 - * @minor: Pointer to where new minor number will be stored 100 100 - * 101 101 - * A bitmask is used to track available minor numbers. Here the next free 102 102 - * minor number is marked as unavailable and returned. 103 103 - * 104 104 - * Return: 0 on success, <0 on failure. 105 105 - */ 106 106 - static int pseudo_lock_minor_get(unsigned int *minor) 107 107 - { 108 108 - unsigned long first_bit; 109 109 - 110 110 - first_bit = find_first_bit(&pseudo_lock_minor_avail, MINORBITS); 111 111 - 112 112 - if (first_bit == MINORBITS) 113 113 - return -ENOSPC; 114 114 - 115 115 - __clear_bit(first_bit, &pseudo_lock_minor_avail); 116 116 - *minor = first_bit; 117 117 - 118 118 - return 0; 119 119 - } 120 120 - 121 121 - /** 122 122 - * pseudo_lock_minor_release - Return minor number to available 123 123 - * @minor: The minor number made available 124 124 - */ 125 125 - static void pseudo_lock_minor_release(unsigned int minor) 126 126 - { 127 127 - __set_bit(minor, &pseudo_lock_minor_avail); 128 128 - } 129 129 - 130 130 - /** 131 131 - * region_find_by_minor - Locate a pseudo-lock region by inode minor number 132 132 - * @minor: The minor number of the device representing pseudo-locked region 133 133 - * 134 134 - * When the character device is accessed we need to determine which 135 135 - * pseudo-locked region it belongs to. This is done by matching the minor 136 136 - * number of the device to the pseudo-locked region it belongs. 137 137 - * 138 138 - * Minor numbers are assigned at the time a pseudo-locked region is associated 139 139 - * with a cache instance. 140 140 - * 141 141 - * Return: On success return pointer to resource group owning the pseudo-locked 142 142 - * region, NULL on failure. 143 143 - */ 144 144 - static struct rdtgroup *region_find_by_minor(unsigned int minor) 145 145 - { 146 146 - struct rdtgroup *rdtgrp, *rdtgrp_match = NULL; 147 147 - 148 148 - list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 149 149 - if (rdtgrp->plr && rdtgrp->plr->minor == minor) { 150 150 - rdtgrp_match = rdtgrp; 151 151 - break; 152 152 - } 153 153 - } 154 154 - return rdtgrp_match; 155 155 - } 156 156 - 157 157 - /** 158 158 - * struct pseudo_lock_pm_req - A power management QoS request list entry 159 159 - * @list: Entry within the @pm_reqs list for a pseudo-locked region 160 160 - * @req: PM QoS request 161 161 - */ 162 162 - struct pseudo_lock_pm_req { 163 163 - struct list_head list; 164 164 - struct dev_pm_qos_request req; 165 165 - }; 166 166 - 167 167 - static void pseudo_lock_cstates_relax(struct pseudo_lock_region *plr) 168 168 - { 169 169 - struct pseudo_lock_pm_req *pm_req, *next; 170 170 - 171 171 - list_for_each_entry_safe(pm_req, next, &plr->pm_reqs, list) { 172 172 - dev_pm_qos_remove_request(&pm_req->req); 173 173 - list_del(&pm_req->list); 174 174 - kfree(pm_req); 175 175 - } 176 176 - } 177 177 - 178 178 - /** 179 179 - * pseudo_lock_cstates_constrain - Restrict cores from entering C6 180 180 - * @plr: Pseudo-locked region 181 181 - * 182 182 - * To prevent the cache from being affected by power management entering 183 183 - * C6 has to be avoided. This is accomplished by requesting a latency 184 184 - * requirement lower than lowest C6 exit latency of all supported 185 185 - * platforms as found in the cpuidle state tables in the intel_idle driver. 186 186 - * At this time it is possible to do so with a single latency requirement 187 187 - * for all supported platforms. 188 188 - * 189 189 - * Since Goldmont is supported, which is affected by X86_BUG_MONITOR, 190 190 - * the ACPI latencies need to be considered while keeping in mind that C2 191 191 - * may be set to map to deeper sleep states. In this case the latency 192 192 - * requirement needs to prevent entering C2 also. 193 193 - * 194 194 - * Return: 0 on success, <0 on failure 195 195 - */ 196 196 - static int pseudo_lock_cstates_constrain(struct pseudo_lock_region *plr) 197 197 - { 198 198 - struct pseudo_lock_pm_req *pm_req; 199 199 - int cpu; 200 200 - int ret; 201 201 - 202 202 - for_each_cpu(cpu, &plr->d->hdr.cpu_mask) { 203 203 - pm_req = kzalloc(sizeof(*pm_req), GFP_KERNEL); 204 204 - if (!pm_req) { 205 205 - rdt_last_cmd_puts("Failure to allocate memory for PM QoS\n"); 206 206 - ret = -ENOMEM; 207 207 - goto out_err; 208 208 - } 209 209 - ret = dev_pm_qos_add_request(get_cpu_device(cpu), 210 210 - &pm_req->req, 211 211 - DEV_PM_QOS_RESUME_LATENCY, 212 212 - 30); 213 213 - if (ret < 0) { 214 214 - rdt_last_cmd_printf("Failed to add latency req CPU%d\n", 215 215 - cpu); 216 216 - kfree(pm_req); 217 217 - ret = -1; 218 218 - goto out_err; 219 219 - } 220 220 - list_add(&pm_req->list, &plr->pm_reqs); 221 221 - } 222 222 - 223 223 - return 0; 224 224 - 225 225 - out_err: 226 226 - pseudo_lock_cstates_relax(plr); 227 227 - return ret; 228 228 - } 229 229 - 230 230 - /** 231 231 - * pseudo_lock_region_clear - Reset pseudo-lock region data 232 232 - * @plr: pseudo-lock region 233 233 - * 234 234 - * All content of the pseudo-locked region is reset - any memory allocated 235 235 - * freed. 236 236 - * 237 237 - * Return: void 238 238 - */ 239 239 - static void pseudo_lock_region_clear(struct pseudo_lock_region *plr) 240 240 - { 241 241 - plr->size = 0; 242 242 - plr->line_size = 0; 243 243 - kfree(plr->kmem); 244 244 - plr->kmem = NULL; 245 245 - plr->s = NULL; 246 246 - if (plr->d) 247 247 - plr->d->plr = NULL; 248 248 - plr->d = NULL; 249 249 - plr->cbm = 0; 250 250 - plr->debugfs_dir = NULL; 251 251 - } 252 252 - 253 253 - /** 254 254 - * pseudo_lock_region_init - Initialize pseudo-lock region information 255 255 - * @plr: pseudo-lock region 256 256 - * 257 257 - * Called after user provided a schemata to be pseudo-locked. From the 258 258 - * schemata the &struct pseudo_lock_region is on entry already initialized 259 259 - * with the resource, domain, and capacity bitmask. Here the information 260 260 - * required for pseudo-locking is deduced from this data and &struct 261 261 - * pseudo_lock_region initialized further. This information includes: 262 262 - * - size in bytes of the region to be pseudo-locked 263 263 - * - cache line size to know the stride with which data needs to be accessed 264 264 - * to be pseudo-locked 265 265 - * - a cpu associated with the cache instance on which the pseudo-locking 266 266 - * flow can be executed 267 267 - * 268 268 - * Return: 0 on success, <0 on failure. Descriptive error will be written 269 269 - * to last_cmd_status buffer. 270 270 - */ 271 271 - static int pseudo_lock_region_init(struct pseudo_lock_region *plr) 272 272 - { 273 273 - enum resctrl_scope scope = plr->s->res->ctrl_scope; 274 274 - struct cacheinfo *ci; 275 275 - int ret; 276 276 - 277 277 - if (WARN_ON_ONCE(scope != RESCTRL_L2_CACHE && scope != RESCTRL_L3_CACHE)) 278 278 - return -ENODEV; 279 279 - 280 280 - /* Pick the first cpu we find that is associated with the cache. */ 281 281 - plr->cpu = cpumask_first(&plr->d->hdr.cpu_mask); 282 282 - 283 283 - if (!cpu_online(plr->cpu)) { 284 284 - rdt_last_cmd_printf("CPU %u associated with cache not online\n", 285 285 - plr->cpu); 286 286 - ret = -ENODEV; 287 287 - goto out_region; 288 288 - } 289 289 - 290 290 - ci = get_cpu_cacheinfo_level(plr->cpu, scope); 291 291 - if (ci) { 292 292 - plr->line_size = ci->coherency_line_size; 293 293 - plr->size = rdtgroup_cbm_to_size(plr->s->res, plr->d, plr->cbm); 294 294 - return 0; 295 295 - } 296 296 - 297 297 - ret = -1; 298 298 - rdt_last_cmd_puts("Unable to determine cache line size\n"); 299 299 - out_region: 300 300 - pseudo_lock_region_clear(plr); 301 301 - return ret; 302 302 - } 303 303 - 304 304 - /** 305 305 - * pseudo_lock_init - Initialize a pseudo-lock region 306 306 - * @rdtgrp: resource group to which new pseudo-locked region will belong 307 307 - * 308 308 - * A pseudo-locked region is associated with a resource group. When this 309 309 - * association is created the pseudo-locked region is initialized. The 310 310 - * details of the pseudo-locked region are not known at this time so only 311 311 - * allocation is done and association established. 312 312 - * 313 313 - * Return: 0 on success, <0 on failure 314 314 - */ 315 315 - static int pseudo_lock_init(struct rdtgroup *rdtgrp) 316 316 - { 317 317 - struct pseudo_lock_region *plr; 318 318 - 319 319 - plr = kzalloc(sizeof(*plr), GFP_KERNEL); 320 320 - if (!plr) 321 321 - return -ENOMEM; 322 322 - 323 323 - init_waitqueue_head(&plr->lock_thread_wq); 324 324 - INIT_LIST_HEAD(&plr->pm_reqs); 325 325 - rdtgrp->plr = plr; 326 326 - return 0; 327 327 - } 328 328 - 329 329 - /** 330 330 - * pseudo_lock_region_alloc - Allocate kernel memory that will be pseudo-locked 331 331 - * @plr: pseudo-lock region 332 332 - * 333 333 - * Initialize the details required to set up the pseudo-locked region and 334 334 - * allocate the contiguous memory that will be pseudo-locked to the cache. 335 335 - * 336 336 - * Return: 0 on success, <0 on failure. Descriptive error will be written 337 337 - * to last_cmd_status buffer. 338 338 - */ 339 339 - static int pseudo_lock_region_alloc(struct pseudo_lock_region *plr) 340 340 - { 341 341 - int ret; 342 342 - 343 343 - ret = pseudo_lock_region_init(plr); 344 344 - if (ret < 0) 345 345 - return ret; 346 346 - 347 347 - /* 348 348 - * We do not yet support contiguous regions larger than 349 349 - * KMALLOC_MAX_SIZE. 350 350 - */ 351 351 - if (plr->size > KMALLOC_MAX_SIZE) { 352 352 - rdt_last_cmd_puts("Requested region exceeds maximum size\n"); 353 353 - ret = -E2BIG; 354 354 - goto out_region; 355 355 - } 356 356 - 357 357 - plr->kmem = kzalloc(plr->size, GFP_KERNEL); 358 358 - if (!plr->kmem) { 359 359 - rdt_last_cmd_puts("Unable to allocate memory\n"); 360 360 - ret = -ENOMEM; 361 361 - goto out_region; 362 362 - } 363 363 - 364 364 - ret = 0; 365 365 - goto out; 366 366 - out_region: 367 367 - pseudo_lock_region_clear(plr); 368 368 - out: 369 369 - return ret; 370 370 - } 371 371 - 372 372 - /** 373 373 - * pseudo_lock_free - Free a pseudo-locked region 374 374 - * @rdtgrp: resource group to which pseudo-locked region belonged 375 375 - * 376 376 - * The pseudo-locked region's resources have already been released, or not 377 377 - * yet created at this point. Now it can be freed and disassociated from the 378 378 - * resource group. 379 379 - * 380 380 - * Return: void 381 381 - */ 382 382 - static void pseudo_lock_free(struct rdtgroup *rdtgrp) 383 383 - { 384 384 - pseudo_lock_region_clear(rdtgrp->plr); 385 385 - kfree(rdtgrp->plr); 386 386 - rdtgrp->plr = NULL; 387 123 } 388 124 389 125 /** ··· 221 541 plr->thread_done = 1; 222 542 wake_up_interruptible(&plr->lock_thread_wq); 223 543 return 0; 224 224 - } 225 225 - 226 226 - /** 227 227 - * rdtgroup_monitor_in_progress - Test if monitoring in progress 228 228 - * @rdtgrp: resource group being queried 229 229 - * 230 230 - * Return: 1 if monitor groups have been created for this resource 231 231 - * group, 0 otherwise. 232 232 - */ 233 233 - static int rdtgroup_monitor_in_progress(struct rdtgroup *rdtgrp) 234 234 - { 235 235 - return !list_empty(&rdtgrp->mon.crdtgrp_list); 236 236 - } 237 237 - 238 238 - /** 239 239 - * rdtgroup_locksetup_user_restrict - Restrict user access to group 240 240 - * @rdtgrp: resource group needing access restricted 241 241 - * 242 242 - * A resource group used for cache pseudo-locking cannot have cpus or tasks 243 243 - * assigned to it. This is communicated to the user by restricting access 244 244 - * to all the files that can be used to make such changes. 245 245 - * 246 246 - * Permissions restored with rdtgroup_locksetup_user_restore() 247 247 - * 248 248 - * Return: 0 on success, <0 on failure. If a failure occurs during the 249 249 - * restriction of access an attempt will be made to restore permissions but 250 250 - * the state of the mode of these files will be uncertain when a failure 251 251 - * occurs. 252 252 - */ 253 253 - static int rdtgroup_locksetup_user_restrict(struct rdtgroup *rdtgrp) 254 254 - { 255 255 - int ret; 256 256 - 257 257 - ret = rdtgroup_kn_mode_restrict(rdtgrp, "tasks"); 258 258 - if (ret) 259 259 - return ret; 260 260 - 261 261 - ret = rdtgroup_kn_mode_restrict(rdtgrp, "cpus"); 262 262 - if (ret) 263 263 - goto err_tasks; 264 264 - 265 265 - ret = rdtgroup_kn_mode_restrict(rdtgrp, "cpus_list"); 266 266 - if (ret) 267 267 - goto err_cpus; 268 268 - 269 269 - if (resctrl_arch_mon_capable()) { 270 270 - ret = rdtgroup_kn_mode_restrict(rdtgrp, "mon_groups"); 271 271 - if (ret) 272 272 - goto err_cpus_list; 273 273 - } 274 274 - 275 275 - ret = 0; 276 276 - goto out; 277 277 - 278 278 - err_cpus_list: 279 279 - rdtgroup_kn_mode_restore(rdtgrp, "cpus_list", 0777); 280 280 - err_cpus: 281 281 - rdtgroup_kn_mode_restore(rdtgrp, "cpus", 0777); 282 282 - err_tasks: 283 283 - rdtgroup_kn_mode_restore(rdtgrp, "tasks", 0777); 284 284 - out: 285 285 - return ret; 286 286 - } 287 287 - 288 288 - /** 289 289 - * rdtgroup_locksetup_user_restore - Restore user access to group 290 290 - * @rdtgrp: resource group needing access restored 291 291 - * 292 292 - * Restore all file access previously removed using 293 293 - * rdtgroup_locksetup_user_restrict() 294 294 - * 295 295 - * Return: 0 on success, <0 on failure. If a failure occurs during the 296 296 - * restoration of access an attempt will be made to restrict permissions 297 297 - * again but the state of the mode of these files will be uncertain when 298 298 - * a failure occurs. 299 299 - */ 300 300 - static int rdtgroup_locksetup_user_restore(struct rdtgroup *rdtgrp) 301 301 - { 302 302 - int ret; 303 303 - 304 304 - ret = rdtgroup_kn_mode_restore(rdtgrp, "tasks", 0777); 305 305 - if (ret) 306 306 - return ret; 307 307 - 308 308 - ret = rdtgroup_kn_mode_restore(rdtgrp, "cpus", 0777); 309 309 - if (ret) 310 310 - goto err_tasks; 311 311 - 312 312 - ret = rdtgroup_kn_mode_restore(rdtgrp, "cpus_list", 0777); 313 313 - if (ret) 314 314 - goto err_cpus; 315 315 - 316 316 - if (resctrl_arch_mon_capable()) { 317 317 - ret = rdtgroup_kn_mode_restore(rdtgrp, "mon_groups", 0777); 318 318 - if (ret) 319 319 - goto err_cpus_list; 320 320 - } 321 321 - 322 322 - ret = 0; 323 323 - goto out; 324 324 - 325 325 - err_cpus_list: 326 326 - rdtgroup_kn_mode_restrict(rdtgrp, "cpus_list"); 327 327 - err_cpus: 328 328 - rdtgroup_kn_mode_restrict(rdtgrp, "cpus"); 329 329 - err_tasks: 330 330 - rdtgroup_kn_mode_restrict(rdtgrp, "tasks"); 331 331 - out: 332 332 - return ret; 333 333 - } 334 334 - 335 335 - /** 336 336 - * rdtgroup_locksetup_enter - Resource group enters locksetup mode 337 337 - * @rdtgrp: resource group requested to enter locksetup mode 338 338 - * 339 339 - * A resource group enters locksetup mode to reflect that it would be used 340 340 - * to represent a pseudo-locked region and is in the process of being set 341 341 - * up to do so. A resource group used for a pseudo-locked region would 342 342 - * lose the closid associated with it so we cannot allow it to have any 343 343 - * tasks or cpus assigned nor permit tasks or cpus to be assigned in the 344 344 - * future. Monitoring of a pseudo-locked region is not allowed either. 345 345 - * 346 346 - * The above and more restrictions on a pseudo-locked region are checked 347 347 - * for and enforced before the resource group enters the locksetup mode. 348 348 - * 349 349 - * Returns: 0 if the resource group successfully entered locksetup mode, <0 350 350 - * on failure. On failure the last_cmd_status buffer is updated with text to 351 351 - * communicate details of failure to the user. 352 352 - */ 353 353 - int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp) 354 354 - { 355 355 - int ret; 356 356 - 357 357 - /* 358 358 - * The default resource group can neither be removed nor lose the 359 359 - * default closid associated with it. 360 360 - */ 361 361 - if (rdtgrp == &rdtgroup_default) { 362 362 - rdt_last_cmd_puts("Cannot pseudo-lock default group\n"); 363 363 - return -EINVAL; 364 364 - } 365 365 - 366 366 - /* 367 367 - * Cache Pseudo-locking not supported when CDP is enabled. 368 368 - * 369 369 - * Some things to consider if you would like to enable this 370 370 - * support (using L3 CDP as example): 371 371 - * - When CDP is enabled two separate resources are exposed, 372 372 - * L3DATA and L3CODE, but they are actually on the same cache. 373 373 - * The implication for pseudo-locking is that if a 374 374 - * pseudo-locked region is created on a domain of one 375 375 - * resource (eg. L3CODE), then a pseudo-locked region cannot 376 376 - * be created on that same domain of the other resource 377 377 - * (eg. L3DATA). This is because the creation of a 378 378 - * pseudo-locked region involves a call to wbinvd that will 379 379 - * affect all cache allocations on particular domain. 380 380 - * - Considering the previous, it may be possible to only 381 381 - * expose one of the CDP resources to pseudo-locking and 382 382 - * hide the other. For example, we could consider to only 383 383 - * expose L3DATA and since the L3 cache is unified it is 384 384 - * still possible to place instructions there are execute it. 385 385 - * - If only one region is exposed to pseudo-locking we should 386 386 - * still keep in mind that availability of a portion of cache 387 387 - * for pseudo-locking should take into account both resources. 388 388 - * Similarly, if a pseudo-locked region is created in one 389 389 - * resource, the portion of cache used by it should be made 390 390 - * unavailable to all future allocations from both resources. 391 391 - */ 392 392 - if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3) || 393 393 - resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) { 394 394 - rdt_last_cmd_puts("CDP enabled\n"); 395 395 - return -EINVAL; 396 396 - } 397 397 - 398 398 - /* 399 399 - * Not knowing the bits to disable prefetching implies that this 400 400 - * platform does not support Cache Pseudo-Locking. 401 401 - */ 402 402 - if (resctrl_arch_get_prefetch_disable_bits() == 0) { 403 403 - rdt_last_cmd_puts("Pseudo-locking not supported\n"); 404 404 - return -EINVAL; 405 405 - } 406 406 - 407 407 - if (rdtgroup_monitor_in_progress(rdtgrp)) { 408 408 - rdt_last_cmd_puts("Monitoring in progress\n"); 409 409 - return -EINVAL; 410 410 - } 411 411 - 412 412 - if (rdtgroup_tasks_assigned(rdtgrp)) { 413 413 - rdt_last_cmd_puts("Tasks assigned to resource group\n"); 414 414 - return -EINVAL; 415 415 - } 416 416 - 417 417 - if (!cpumask_empty(&rdtgrp->cpu_mask)) { 418 418 - rdt_last_cmd_puts("CPUs assigned to resource group\n"); 419 419 - return -EINVAL; 420 420 - } 421 421 - 422 422 - if (rdtgroup_locksetup_user_restrict(rdtgrp)) { 423 423 - rdt_last_cmd_puts("Unable to modify resctrl permissions\n"); 424 424 - return -EIO; 425 425 - } 426 426 - 427 427 - ret = pseudo_lock_init(rdtgrp); 428 428 - if (ret) { 429 429 - rdt_last_cmd_puts("Unable to init pseudo-lock region\n"); 430 430 - goto out_release; 431 431 - } 432 432 - 433 433 - /* 434 434 - * If this system is capable of monitoring a rmid would have been 435 435 - * allocated when the control group was created. This is not needed 436 436 - * anymore when this group would be used for pseudo-locking. This 437 437 - * is safe to call on platforms not capable of monitoring. 438 438 - */ 439 439 - free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 440 440 - 441 441 - ret = 0; 442 442 - goto out; 443 443 - 444 444 - out_release: 445 445 - rdtgroup_locksetup_user_restore(rdtgrp); 446 446 - out: 447 447 - return ret; 448 448 - } 449 449 - 450 450 - /** 451 451 - * rdtgroup_locksetup_exit - resource group exist locksetup mode 452 452 - * @rdtgrp: resource group 453 453 - * 454 454 - * When a resource group exits locksetup mode the earlier restrictions are 455 455 - * lifted. 456 456 - * 457 457 - * Return: 0 on success, <0 on failure 458 458 - */ 459 459 - int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp) 460 460 - { 461 461 - int ret; 462 462 - 463 463 - if (resctrl_arch_mon_capable()) { 464 464 - ret = alloc_rmid(rdtgrp->closid); 465 465 - if (ret < 0) { 466 466 - rdt_last_cmd_puts("Out of RMIDs\n"); 467 467 - return ret; 468 468 - } 469 469 - rdtgrp->mon.rmid = ret; 470 470 - } 471 471 - 472 472 - ret = rdtgroup_locksetup_user_restore(rdtgrp); 473 473 - if (ret) { 474 474 - free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 475 475 - return ret; 476 476 - } 477 477 - 478 478 - pseudo_lock_free(rdtgrp); 479 479 - return 0; 480 480 - } 481 481 - 482 482 - /** 483 483 - * rdtgroup_cbm_overlaps_pseudo_locked - Test if CBM or portion is pseudo-locked 484 484 - * @d: RDT domain 485 485 - * @cbm: CBM to test 486 486 - * 487 487 - * @d represents a cache instance and @cbm a capacity bitmask that is 488 488 - * considered for it. Determine if @cbm overlaps with any existing 489 489 - * pseudo-locked region on @d. 490 490 - * 491 491 - * @cbm is unsigned long, even if only 32 bits are used, to make the 492 492 - * bitmap functions work correctly. 493 493 - * 494 494 - * Return: true if @cbm overlaps with pseudo-locked region on @d, false 495 495 - * otherwise. 496 496 - */ 497 497 - bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_ctrl_domain *d, unsigned long cbm) 498 498 - { 499 499 - unsigned int cbm_len; 500 500 - unsigned long cbm_b; 501 501 - 502 502 - if (d->plr) { 503 503 - cbm_len = d->plr->s->res->cache.cbm_len; 504 504 - cbm_b = d->plr->cbm; 505 505 - if (bitmap_intersects(&cbm, &cbm_b, cbm_len)) 506 506 - return true; 507 507 - } 508 508 - return false; 509 509 - } 510 510 - 511 511 - /** 512 512 - * rdtgroup_pseudo_locked_in_hierarchy - Pseudo-locked region in cache hierarchy 513 513 - * @d: RDT domain under test 514 514 - * 515 515 - * The setup of a pseudo-locked region affects all cache instances within 516 516 - * the hierarchy of the region. It is thus essential to know if any 517 517 - * pseudo-locked regions exist within a cache hierarchy to prevent any 518 518 - * attempts to create new pseudo-locked regions in the same hierarchy. 519 519 - * 520 520 - * Return: true if a pseudo-locked region exists in the hierarchy of @d or 521 521 - * if it is not possible to test due to memory allocation issue, 522 522 - * false otherwise. 523 523 - */ 524 524 - bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_ctrl_domain *d) 525 525 - { 526 526 - struct rdt_ctrl_domain *d_i; 527 527 - cpumask_var_t cpu_with_psl; 528 528 - struct rdt_resource *r; 529 529 - bool ret = false; 530 530 - 531 531 - /* Walking r->domains, ensure it can't race with cpuhp */ 532 532 - lockdep_assert_cpus_held(); 533 533 - 534 534 - if (!zalloc_cpumask_var(&cpu_with_psl, GFP_KERNEL)) 535 535 - return true; 536 536 - 537 537 - /* 538 538 - * First determine which cpus have pseudo-locked regions 539 539 - * associated with them. 540 540 - */ 541 541 - for_each_alloc_capable_rdt_resource(r) { 542 542 - list_for_each_entry(d_i, &r->ctrl_domains, hdr.list) { 543 543 - if (d_i->plr) 544 544 - cpumask_or(cpu_with_psl, cpu_with_psl, 545 545 - &d_i->hdr.cpu_mask); 546 546 - } 547 547 - } 548 548 - 549 549 - /* 550 550 - * Next test if new pseudo-locked region would intersect with 551 551 - * existing region. 552 552 - */ 553 553 - if (cpumask_intersects(&d->hdr.cpu_mask, cpu_with_psl)) 554 554 - ret = true; 555 555 - 556 556 - free_cpumask_var(cpu_with_psl); 557 557 - return ret; 558 544 } 559 545 560 546 /** ··· 514 1168 plr->thread_done = 1; 515 1169 wake_up_interruptible(&plr->lock_thread_wq); 516 1170 return 0; 517 517 - } 518 518 - 519 519 - /** 520 520 - * pseudo_lock_measure_cycles - Trigger latency measure to pseudo-locked region 521 521 - * @rdtgrp: Resource group to which the pseudo-locked region belongs. 522 522 - * @sel: Selector of which measurement to perform on a pseudo-locked region. 523 523 - * 524 524 - * The measurement of latency to access a pseudo-locked region should be 525 525 - * done from a cpu that is associated with that pseudo-locked region. 526 526 - * Determine which cpu is associated with this region and start a thread on 527 527 - * that cpu to perform the measurement, wait for that thread to complete. 528 528 - * 529 529 - * Return: 0 on success, <0 on failure 530 530 - */ 531 531 - static int pseudo_lock_measure_cycles(struct rdtgroup *rdtgrp, int sel) 532 532 - { 533 533 - struct pseudo_lock_region *plr = rdtgrp->plr; 534 534 - struct task_struct *thread; 535 535 - unsigned int cpu; 536 536 - int ret = -1; 537 537 - 538 538 - cpus_read_lock(); 539 539 - mutex_lock(&rdtgroup_mutex); 540 540 - 541 541 - if (rdtgrp->flags & RDT_DELETED) { 542 542 - ret = -ENODEV; 543 543 - goto out; 544 544 - } 545 545 - 546 546 - if (!plr->d) { 547 547 - ret = -ENODEV; 548 548 - goto out; 549 549 - } 550 550 - 551 551 - plr->thread_done = 0; 552 552 - cpu = cpumask_first(&plr->d->hdr.cpu_mask); 553 553 - if (!cpu_online(cpu)) { 554 554 - ret = -ENODEV; 555 555 - goto out; 556 556 - } 557 557 - 558 558 - plr->cpu = cpu; 559 559 - 560 560 - if (sel == 1) 561 561 - thread = kthread_run_on_cpu(resctrl_arch_measure_cycles_lat_fn, 562 562 - plr, cpu, "pseudo_lock_measure/%u"); 563 563 - else if (sel == 2) 564 564 - thread = kthread_run_on_cpu(resctrl_arch_measure_l2_residency, 565 565 - plr, cpu, "pseudo_lock_measure/%u"); 566 566 - else if (sel == 3) 567 567 - thread = kthread_run_on_cpu(resctrl_arch_measure_l3_residency, 568 568 - plr, cpu, "pseudo_lock_measure/%u"); 569 569 - else 570 570 - goto out; 571 571 - 572 572 - if (IS_ERR(thread)) { 573 573 - ret = PTR_ERR(thread); 574 574 - goto out; 575 575 - } 576 576 - 577 577 - ret = wait_event_interruptible(plr->lock_thread_wq, 578 578 - plr->thread_done == 1); 579 579 - if (ret < 0) 580 580 - goto out; 581 581 - 582 582 - ret = 0; 583 583 - 584 584 - out: 585 585 - mutex_unlock(&rdtgroup_mutex); 586 586 - cpus_read_unlock(); 587 587 - return ret; 588 588 - } 589 589 - 590 590 - static ssize_t pseudo_lock_measure_trigger(struct file *file, 591 591 - const char __user *user_buf, 592 592 - size_t count, loff_t *ppos) 593 593 - { 594 594 - struct rdtgroup *rdtgrp = file->private_data; 595 595 - size_t buf_size; 596 596 - char buf[32]; 597 597 - int ret; 598 598 - int sel; 599 599 - 600 600 - buf_size = min(count, (sizeof(buf) - 1)); 601 601 - if (copy_from_user(buf, user_buf, buf_size)) 602 602 - return -EFAULT; 603 603 - 604 604 - buf[buf_size] = '\0'; 605 605 - ret = kstrtoint(buf, 10, &sel); 606 606 - if (ret == 0) { 607 607 - if (sel != 1 && sel != 2 && sel != 3) 608 608 - return -EINVAL; 609 609 - ret = debugfs_file_get(file->f_path.dentry); 610 610 - if (ret) 611 611 - return ret; 612 612 - ret = pseudo_lock_measure_cycles(rdtgrp, sel); 613 613 - if (ret == 0) 614 614 - ret = count; 615 615 - debugfs_file_put(file->f_path.dentry); 616 616 - } 617 617 - 618 618 - return ret; 619 619 - } 620 620 - 621 621 - static const struct file_operations pseudo_measure_fops = { 622 622 - .write = pseudo_lock_measure_trigger, 623 623 - .open = simple_open, 624 624 - .llseek = default_llseek, 625 625 - }; 626 626 - 627 627 - /** 628 628 - * rdtgroup_pseudo_lock_create - Create a pseudo-locked region 629 629 - * @rdtgrp: resource group to which pseudo-lock region belongs 630 630 - * 631 631 - * Called when a resource group in the pseudo-locksetup mode receives a 632 632 - * valid schemata that should be pseudo-locked. Since the resource group is 633 633 - * in pseudo-locksetup mode the &struct pseudo_lock_region has already been 634 634 - * allocated and initialized with the essential information. If a failure 635 635 - * occurs the resource group remains in the pseudo-locksetup mode with the 636 636 - * &struct pseudo_lock_region associated with it, but cleared from all 637 637 - * information and ready for the user to re-attempt pseudo-locking by 638 638 - * writing the schemata again. 639 639 - * 640 640 - * Return: 0 if the pseudo-locked region was successfully pseudo-locked, <0 641 641 - * on failure. Descriptive error will be written to last_cmd_status buffer. 642 642 - */ 643 643 - int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp) 644 644 - { 645 645 - struct pseudo_lock_region *plr = rdtgrp->plr; 646 646 - struct task_struct *thread; 647 647 - unsigned int new_minor; 648 648 - struct device *dev; 649 649 - char *kn_name __free(kfree) = NULL; 650 650 - int ret; 651 651 - 652 652 - ret = pseudo_lock_region_alloc(plr); 653 653 - if (ret < 0) 654 654 - return ret; 655 655 - 656 656 - ret = pseudo_lock_cstates_constrain(plr); 657 657 - if (ret < 0) { 658 658 - ret = -EINVAL; 659 659 - goto out_region; 660 660 - } 661 661 - kn_name = kstrdup(rdt_kn_name(rdtgrp->kn), GFP_KERNEL); 662 662 - if (!kn_name) { 663 663 - ret = -ENOMEM; 664 664 - goto out_cstates; 665 665 - } 666 666 - 667 667 - plr->thread_done = 0; 668 668 - 669 669 - thread = kthread_run_on_cpu(resctrl_arch_pseudo_lock_fn, plr, 670 670 - plr->cpu, "pseudo_lock/%u"); 671 671 - if (IS_ERR(thread)) { 672 672 - ret = PTR_ERR(thread); 673 673 - rdt_last_cmd_printf("Locking thread returned error %d\n", ret); 674 674 - goto out_cstates; 675 675 - } 676 676 - 677 677 - ret = wait_event_interruptible(plr->lock_thread_wq, 678 678 - plr->thread_done == 1); 679 679 - if (ret < 0) { 680 680 - /* 681 681 - * If the thread does not get on the CPU for whatever 682 682 - * reason and the process which sets up the region is 683 683 - * interrupted then this will leave the thread in runnable 684 684 - * state and once it gets on the CPU it will dereference 685 685 - * the cleared, but not freed, plr struct resulting in an 686 686 - * empty pseudo-locking loop. 687 687 - */ 688 688 - rdt_last_cmd_puts("Locking thread interrupted\n"); 689 689 - goto out_cstates; 690 690 - } 691 691 - 692 692 - ret = pseudo_lock_minor_get(&new_minor); 693 693 - if (ret < 0) { 694 694 - rdt_last_cmd_puts("Unable to obtain a new minor number\n"); 695 695 - goto out_cstates; 696 696 - } 697 697 - 698 698 - /* 699 699 - * Unlock access but do not release the reference. The 700 700 - * pseudo-locked region will still be here on return. 701 701 - * 702 702 - * The mutex has to be released temporarily to avoid a potential 703 703 - * deadlock with the mm->mmap_lock which is obtained in the 704 704 - * device_create() and debugfs_create_dir() callpath below as well as 705 705 - * before the mmap() callback is called. 706 706 - */ 707 707 - mutex_unlock(&rdtgroup_mutex); 708 708 - 709 709 - if (!IS_ERR_OR_NULL(debugfs_resctrl)) { 710 710 - plr->debugfs_dir = debugfs_create_dir(kn_name, debugfs_resctrl); 711 711 - if (!IS_ERR_OR_NULL(plr->debugfs_dir)) 712 712 - debugfs_create_file("pseudo_lock_measure", 0200, 713 713 - plr->debugfs_dir, rdtgrp, 714 714 - &pseudo_measure_fops); 715 715 - } 716 716 - 717 717 - dev = device_create(&pseudo_lock_class, NULL, 718 718 - MKDEV(pseudo_lock_major, new_minor), 719 719 - rdtgrp, "%s", kn_name); 720 720 - 721 721 - mutex_lock(&rdtgroup_mutex); 722 722 - 723 723 - if (IS_ERR(dev)) { 724 724 - ret = PTR_ERR(dev); 725 725 - rdt_last_cmd_printf("Failed to create character device: %d\n", 726 726 - ret); 727 727 - goto out_debugfs; 728 728 - } 729 729 - 730 730 - /* We released the mutex - check if group was removed while we did so */ 731 731 - if (rdtgrp->flags & RDT_DELETED) { 732 732 - ret = -ENODEV; 733 733 - goto out_device; 734 734 - } 735 735 - 736 736 - plr->minor = new_minor; 737 737 - 738 738 - rdtgrp->mode = RDT_MODE_PSEUDO_LOCKED; 739 739 - closid_free(rdtgrp->closid); 740 740 - rdtgroup_kn_mode_restore(rdtgrp, "cpus", 0444); 741 741 - rdtgroup_kn_mode_restore(rdtgrp, "cpus_list", 0444); 742 742 - 743 743 - ret = 0; 744 744 - goto out; 745 745 - 746 746 - out_device: 747 747 - device_destroy(&pseudo_lock_class, MKDEV(pseudo_lock_major, new_minor)); 748 748 - out_debugfs: 749 749 - debugfs_remove_recursive(plr->debugfs_dir); 750 750 - pseudo_lock_minor_release(new_minor); 751 751 - out_cstates: 752 752 - pseudo_lock_cstates_relax(plr); 753 753 - out_region: 754 754 - pseudo_lock_region_clear(plr); 755 755 - out: 756 756 - return ret; 757 757 - } 758 758 - 759 759 - /** 760 760 - * rdtgroup_pseudo_lock_remove - Remove a pseudo-locked region 761 761 - * @rdtgrp: resource group to which the pseudo-locked region belongs 762 762 - * 763 763 - * The removal of a pseudo-locked region can be initiated when the resource 764 764 - * group is removed from user space via a "rmdir" from userspace or the 765 765 - * unmount of the resctrl filesystem. On removal the resource group does 766 766 - * not go back to pseudo-locksetup mode before it is removed, instead it is 767 767 - * removed directly. There is thus asymmetry with the creation where the 768 768 - * &struct pseudo_lock_region is removed here while it was not created in 769 769 - * rdtgroup_pseudo_lock_create(). 770 770 - * 771 771 - * Return: void 772 772 - */ 773 773 - void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp) 774 774 - { 775 775 - struct pseudo_lock_region *plr = rdtgrp->plr; 776 776 - 777 777 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 778 778 - /* 779 779 - * Default group cannot be a pseudo-locked region so we can 780 780 - * free closid here. 781 781 - */ 782 782 - closid_free(rdtgrp->closid); 783 783 - goto free; 784 784 - } 785 785 - 786 786 - pseudo_lock_cstates_relax(plr); 787 787 - debugfs_remove_recursive(rdtgrp->plr->debugfs_dir); 788 788 - device_destroy(&pseudo_lock_class, MKDEV(pseudo_lock_major, plr->minor)); 789 789 - pseudo_lock_minor_release(plr->minor); 790 790 - 791 791 - free: 792 792 - pseudo_lock_free(rdtgrp); 793 793 - } 794 794 - 795 795 - static int pseudo_lock_dev_open(struct inode *inode, struct file *filp) 796 796 - { 797 797 - struct rdtgroup *rdtgrp; 798 798 - 799 799 - mutex_lock(&rdtgroup_mutex); 800 800 - 801 801 - rdtgrp = region_find_by_minor(iminor(inode)); 802 802 - if (!rdtgrp) { 803 803 - mutex_unlock(&rdtgroup_mutex); 804 804 - return -ENODEV; 805 805 - } 806 806 - 807 807 - filp->private_data = rdtgrp; 808 808 - atomic_inc(&rdtgrp->waitcount); 809 809 - /* Perform a non-seekable open - llseek is not supported */ 810 810 - filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE); 811 811 - 812 812 - mutex_unlock(&rdtgroup_mutex); 813 813 - 814 814 - return 0; 815 815 - } 816 816 - 817 817 - static int pseudo_lock_dev_release(struct inode *inode, struct file *filp) 818 818 - { 819 819 - struct rdtgroup *rdtgrp; 820 820 - 821 821 - mutex_lock(&rdtgroup_mutex); 822 822 - rdtgrp = filp->private_data; 823 823 - WARN_ON(!rdtgrp); 824 824 - if (!rdtgrp) { 825 825 - mutex_unlock(&rdtgroup_mutex); 826 826 - return -ENODEV; 827 827 - } 828 828 - filp->private_data = NULL; 829 829 - atomic_dec(&rdtgrp->waitcount); 830 830 - mutex_unlock(&rdtgroup_mutex); 831 831 - return 0; 832 832 - } 833 833 - 834 834 - static int pseudo_lock_dev_mremap(struct vm_area_struct *area) 835 835 - { 836 836 - /* Not supported */ 837 837 - return -EINVAL; 838 838 - } 839 839 - 840 840 - static const struct vm_operations_struct pseudo_mmap_ops = { 841 841 - .mremap = pseudo_lock_dev_mremap, 842 842 - }; 843 843 - 844 844 - static int pseudo_lock_dev_mmap(struct file *filp, struct vm_area_struct *vma) 845 845 - { 846 846 - unsigned long vsize = vma->vm_end - vma->vm_start; 847 847 - unsigned long off = vma->vm_pgoff << PAGE_SHIFT; 848 848 - struct pseudo_lock_region *plr; 849 849 - struct rdtgroup *rdtgrp; 850 850 - unsigned long physical; 851 851 - unsigned long psize; 852 852 - 853 853 - mutex_lock(&rdtgroup_mutex); 854 854 - 855 855 - rdtgrp = filp->private_data; 856 856 - WARN_ON(!rdtgrp); 857 857 - if (!rdtgrp) { 858 858 - mutex_unlock(&rdtgroup_mutex); 859 859 - return -ENODEV; 860 860 - } 861 861 - 862 862 - plr = rdtgrp->plr; 863 863 - 864 864 - if (!plr->d) { 865 865 - mutex_unlock(&rdtgroup_mutex); 866 866 - return -ENODEV; 867 867 - } 868 868 - 869 869 - /* 870 870 - * Task is required to run with affinity to the cpus associated 871 871 - * with the pseudo-locked region. If this is not the case the task 872 872 - * may be scheduled elsewhere and invalidate entries in the 873 873 - * pseudo-locked region. 874 874 - */ 875 875 - if (!cpumask_subset(current->cpus_ptr, &plr->d->hdr.cpu_mask)) { 876 876 - mutex_unlock(&rdtgroup_mutex); 877 877 - return -EINVAL; 878 878 - } 879 879 - 880 880 - physical = __pa(plr->kmem) >> PAGE_SHIFT; 881 881 - psize = plr->size - off; 882 882 - 883 883 - if (off > plr->size) { 884 884 - mutex_unlock(&rdtgroup_mutex); 885 885 - return -ENOSPC; 886 886 - } 887 887 - 888 888 - /* 889 889 - * Ensure changes are carried directly to the memory being mapped, 890 890 - * do not allow copy-on-write mapping. 891 891 - */ 892 892 - if (!(vma->vm_flags & VM_SHARED)) { 893 893 - mutex_unlock(&rdtgroup_mutex); 894 894 - return -EINVAL; 895 895 - } 896 896 - 897 897 - if (vsize > psize) { 898 898 - mutex_unlock(&rdtgroup_mutex); 899 899 - return -ENOSPC; 900 900 - } 901 901 - 902 902 - memset(plr->kmem + off, 0, vsize); 903 903 - 904 904 - if (remap_pfn_range(vma, vma->vm_start, physical + vma->vm_pgoff, 905 905 - vsize, vma->vm_page_prot)) { 906 906 - mutex_unlock(&rdtgroup_mutex); 907 907 - return -EAGAIN; 908 908 - } 909 909 - vma->vm_ops = &pseudo_mmap_ops; 910 910 - mutex_unlock(&rdtgroup_mutex); 911 911 - return 0; 912 912 - } 913 913 - 914 914 - static const struct file_operations pseudo_lock_dev_fops = { 915 915 - .owner = THIS_MODULE, 916 916 - .read = NULL, 917 917 - .write = NULL, 918 918 - .open = pseudo_lock_dev_open, 919 919 - .release = pseudo_lock_dev_release, 920 920 - .mmap = pseudo_lock_dev_mmap, 921 921 - }; 922 922 - 923 923 - int rdt_pseudo_lock_init(void) 924 924 - { 925 925 - int ret; 926 926 - 927 927 - ret = register_chrdev(0, "pseudo_lock", &pseudo_lock_dev_fops); 928 928 - if (ret < 0) 929 929 - return ret; 930 930 - 931 931 - pseudo_lock_major = ret; 932 932 - 933 933 - ret = class_register(&pseudo_lock_class); 934 934 - if (ret) { 935 935 - unregister_chrdev(pseudo_lock_major, "pseudo_lock"); 936 936 - return ret; 937 937 - } 938 938 - 939 939 - return 0; 940 940 - } 941 941 - 942 942 - void rdt_pseudo_lock_release(void) 943 943 - { 944 944 - class_unregister(&pseudo_lock_class); 945 945 - unregister_chrdev(pseudo_lock_major, "pseudo_lock"); 946 946 - pseudo_lock_major = 0; 947 1171 }

+7 -4157

arch/x86/kernel/cpu/resctrl/rdtgroup.c

reviewed

··· 18 18 #include <linux/fs_parser.h> 19 19 #include <linux/sysfs.h> 20 20 #include <linux/kernfs.h> 21 21 + #include <linux/resctrl.h> 21 22 #include <linux/seq_buf.h> 22 23 #include <linux/seq_file.h> 23 24 #include <linux/sched/signal.h> ··· 30 29 #include <uapi/linux/magic.h> 31 30 32 31 #include <asm/msr.h> 33 33 - #include <asm/resctrl.h> 34 32 #include "internal.h" 35 33 36 34 DEFINE_STATIC_KEY_FALSE(rdt_enable_key); 35 35 + 37 36 DEFINE_STATIC_KEY_FALSE(rdt_mon_enable_key); 37 37 + 38 38 DEFINE_STATIC_KEY_FALSE(rdt_alloc_enable_key); 39 39 40 40 - /* Mutex to protect rdtgroup access. */ 41 41 - DEFINE_MUTEX(rdtgroup_mutex); 42 42 - 43 43 - static struct kernfs_root *rdt_root; 44 44 - struct rdtgroup rdtgroup_default; 45 45 - LIST_HEAD(rdt_all_groups); 46 46 - 47 47 - /* list of entries for the schemata file */ 48 48 - LIST_HEAD(resctrl_schema_all); 49 49 - 50 50 - /* The filesystem can only be mounted once. */ 51 51 - bool resctrl_mounted; 52 52 - 53 53 - /* Kernel fs node for "info" directory under root */ 54 54 - static struct kernfs_node *kn_info; 55 55 - 56 56 - /* Kernel fs node for "mon_groups" directory under root */ 57 57 - static struct kernfs_node *kn_mongrp; 58 58 - 59 59 - /* Kernel fs node for "mon_data" directory under root */ 60 60 - static struct kernfs_node *kn_mondata; 61 61 - 62 40 /* 63 63 - * Used to store the max resource name width to display the schemata names in 64 64 - * a tabular format. 65 65 - */ 66 66 - int max_name_width; 67 67 - 68 68 - static struct seq_buf last_cmd_status; 69 69 - static char last_cmd_status_buf[512]; 70 70 - 71 71 - static int rdtgroup_setup_root(struct rdt_fs_context *ctx); 72 72 - static void rdtgroup_destroy_root(void); 73 73 - 74 74 - struct dentry *debugfs_resctrl; 75 75 - 76 76 - /* 77 77 - * Memory bandwidth monitoring event to use for the default CTRL_MON group 78 78 - * and each new CTRL_MON group created by the user. Only relevant when 79 79 - * the filesystem is mounted with the "mba_MBps" option so it does not 80 80 - * matter that it remains uninitialized on systems that do not support 81 81 - * the "mba_MBps" option. 82 82 - */ 83 83 - enum resctrl_event_id mba_mbps_default_event; 84 84 - 85 85 - static bool resctrl_debug; 86 86 - 87 87 - void rdt_last_cmd_clear(void) 88 88 - { 89 89 - lockdep_assert_held(&rdtgroup_mutex); 90 90 - seq_buf_clear(&last_cmd_status); 91 91 - } 92 92 - 93 93 - void rdt_last_cmd_puts(const char *s) 94 94 - { 95 95 - lockdep_assert_held(&rdtgroup_mutex); 96 96 - seq_buf_puts(&last_cmd_status, s); 97 97 - } 98 98 - 99 99 - void rdt_last_cmd_printf(const char *fmt, ...) 100 100 - { 101 101 - va_list ap; 102 102 - 103 103 - va_start(ap, fmt); 104 104 - lockdep_assert_held(&rdtgroup_mutex); 105 105 - seq_buf_vprintf(&last_cmd_status, fmt, ap); 106 106 - va_end(ap); 107 107 - } 108 108 - 109 109 - void rdt_staged_configs_clear(void) 110 110 - { 111 111 - struct rdt_ctrl_domain *dom; 112 112 - struct rdt_resource *r; 113 113 - 114 114 - lockdep_assert_held(&rdtgroup_mutex); 115 115 - 116 116 - for_each_alloc_capable_rdt_resource(r) { 117 117 - list_for_each_entry(dom, &r->ctrl_domains, hdr.list) 118 118 - memset(dom->staged_config, 0, sizeof(dom->staged_config)); 119 119 - } 120 120 - } 121 121 - 122 122 - static bool resctrl_is_mbm_enabled(void) 123 123 - { 124 124 - return (resctrl_arch_is_mbm_total_enabled() || 125 125 - resctrl_arch_is_mbm_local_enabled()); 126 126 - } 127 127 - 128 128 - static bool resctrl_is_mbm_event(int e) 129 129 - { 130 130 - return (e >= QOS_L3_MBM_TOTAL_EVENT_ID && 131 131 - e <= QOS_L3_MBM_LOCAL_EVENT_ID); 132 132 - } 133 133 - 134 134 - /* 135 135 - * Trivial allocator for CLOSIDs. Since h/w only supports a small number, 136 136 - * we can keep a bitmap of free CLOSIDs in a single integer. 137 137 - * 138 138 - * Using a global CLOSID across all resources has some advantages and 139 139 - * some drawbacks: 140 140 - * + We can simply set current's closid to assign a task to a resource 141 141 - * group. 142 142 - * + Context switch code can avoid extra memory references deciding which 143 143 - * CLOSID to load into the PQR_ASSOC MSR 144 144 - * - We give up some options in configuring resource groups across multi-socket 145 145 - * systems. 146 146 - * - Our choices on how to configure each resource become progressively more 147 147 - * limited as the number of resources grows. 148 148 - */ 149 149 - static unsigned long closid_free_map; 150 150 - static int closid_free_map_len; 151 151 - 152 152 - int closids_supported(void) 153 153 - { 154 154 - return closid_free_map_len; 155 155 - } 156 156 - 157 157 - static void closid_init(void) 158 158 - { 159 159 - struct resctrl_schema *s; 160 160 - u32 rdt_min_closid = 32; 161 161 - 162 162 - /* Compute rdt_min_closid across all resources */ 163 163 - list_for_each_entry(s, &resctrl_schema_all, list) 164 164 - rdt_min_closid = min(rdt_min_closid, s->num_closid); 165 165 - 166 166 - closid_free_map = BIT_MASK(rdt_min_closid) - 1; 167 167 - 168 168 - /* RESCTRL_RESERVED_CLOSID is always reserved for the default group */ 169 169 - __clear_bit(RESCTRL_RESERVED_CLOSID, &closid_free_map); 170 170 - closid_free_map_len = rdt_min_closid; 171 171 - } 172 172 - 173 173 - static int closid_alloc(void) 174 174 - { 175 175 - int cleanest_closid; 176 176 - u32 closid; 177 177 - 178 178 - lockdep_assert_held(&rdtgroup_mutex); 179 179 - 180 180 - if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID) && 181 181 - resctrl_arch_is_llc_occupancy_enabled()) { 182 182 - cleanest_closid = resctrl_find_cleanest_closid(); 183 183 - if (cleanest_closid < 0) 184 184 - return cleanest_closid; 185 185 - closid = cleanest_closid; 186 186 - } else { 187 187 - closid = ffs(closid_free_map); 188 188 - if (closid == 0) 189 189 - return -ENOSPC; 190 190 - closid--; 191 191 - } 192 192 - __clear_bit(closid, &closid_free_map); 193 193 - 194 194 - return closid; 195 195 - } 196 196 - 197 197 - void closid_free(int closid) 198 198 - { 199 199 - lockdep_assert_held(&rdtgroup_mutex); 200 200 - 201 201 - __set_bit(closid, &closid_free_map); 202 202 - } 203 203 - 204 204 - /** 205 205 - * closid_allocated - test if provided closid is in use 206 206 - * @closid: closid to be tested 207 207 - * 208 208 - * Return: true if @closid is currently associated with a resource group, 209 209 - * false if @closid is free 210 210 - */ 211 211 - bool closid_allocated(unsigned int closid) 212 212 - { 213 213 - lockdep_assert_held(&rdtgroup_mutex); 214 214 - 215 215 - return !test_bit(closid, &closid_free_map); 216 216 - } 217 217 - 218 218 - /** 219 219 - * rdtgroup_mode_by_closid - Return mode of resource group with closid 220 220 - * @closid: closid if the resource group 221 221 - * 222 222 - * Each resource group is associated with a @closid. Here the mode 223 223 - * of a resource group can be queried by searching for it using its closid. 224 224 - * 225 225 - * Return: mode as &enum rdtgrp_mode of resource group with closid @closid 226 226 - */ 227 227 - enum rdtgrp_mode rdtgroup_mode_by_closid(int closid) 228 228 - { 229 229 - struct rdtgroup *rdtgrp; 230 230 - 231 231 - list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 232 232 - if (rdtgrp->closid == closid) 233 233 - return rdtgrp->mode; 234 234 - } 235 235 - 236 236 - return RDT_NUM_MODES; 237 237 - } 238 238 - 239 239 - static const char * const rdt_mode_str[] = { 240 240 - [RDT_MODE_SHAREABLE] = "shareable", 241 241 - [RDT_MODE_EXCLUSIVE] = "exclusive", 242 242 - [RDT_MODE_PSEUDO_LOCKSETUP] = "pseudo-locksetup", 243 243 - [RDT_MODE_PSEUDO_LOCKED] = "pseudo-locked", 244 244 - }; 245 245 - 246 246 - /** 247 247 - * rdtgroup_mode_str - Return the string representation of mode 248 248 - * @mode: the resource group mode as &enum rdtgroup_mode 249 249 - * 250 250 - * Return: string representation of valid mode, "unknown" otherwise 251 251 - */ 252 252 - static const char *rdtgroup_mode_str(enum rdtgrp_mode mode) 253 253 - { 254 254 - if (mode < RDT_MODE_SHAREABLE || mode >= RDT_NUM_MODES) 255 255 - return "unknown"; 256 256 - 257 257 - return rdt_mode_str[mode]; 258 258 - } 259 259 - 260 260 - /* set uid and gid of rdtgroup dirs and files to that of the creator */ 261 261 - static int rdtgroup_kn_set_ugid(struct kernfs_node *kn) 262 262 - { 263 263 - struct iattr iattr = { .ia_valid = ATTR_UID | ATTR_GID, 264 264 - .ia_uid = current_fsuid(), 265 265 - .ia_gid = current_fsgid(), }; 266 266 - 267 267 - if (uid_eq(iattr.ia_uid, GLOBAL_ROOT_UID) && 268 268 - gid_eq(iattr.ia_gid, GLOBAL_ROOT_GID)) 269 269 - return 0; 270 270 - 271 271 - return kernfs_setattr(kn, &iattr); 272 272 - } 273 273 - 274 274 - static int rdtgroup_add_file(struct kernfs_node *parent_kn, struct rftype *rft) 275 275 - { 276 276 - struct kernfs_node *kn; 277 277 - int ret; 278 278 - 279 279 - kn = __kernfs_create_file(parent_kn, rft->name, rft->mode, 280 280 - GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 281 281 - 0, rft->kf_ops, rft, NULL, NULL); 282 282 - if (IS_ERR(kn)) 283 283 - return PTR_ERR(kn); 284 284 - 285 285 - ret = rdtgroup_kn_set_ugid(kn); 286 286 - if (ret) { 287 287 - kernfs_remove(kn); 288 288 - return ret; 289 289 - } 290 290 - 291 291 - return 0; 292 292 - } 293 293 - 294 294 - static int rdtgroup_seqfile_show(struct seq_file *m, void *arg) 295 295 - { 296 296 - struct kernfs_open_file *of = m->private; 297 297 - struct rftype *rft = of->kn->priv; 298 298 - 299 299 - if (rft->seq_show) 300 300 - return rft->seq_show(of, m, arg); 301 301 - return 0; 302 302 - } 303 303 - 304 304 - static ssize_t rdtgroup_file_write(struct kernfs_open_file *of, char *buf, 305 305 - size_t nbytes, loff_t off) 306 306 - { 307 307 - struct rftype *rft = of->kn->priv; 308 308 - 309 309 - if (rft->write) 310 310 - return rft->write(of, buf, nbytes, off); 311 311 - 312 312 - return -EINVAL; 313 313 - } 314 314 - 315 315 - static const struct kernfs_ops rdtgroup_kf_single_ops = { 316 316 - .atomic_write_len = PAGE_SIZE, 317 317 - .write = rdtgroup_file_write, 318 318 - .seq_show = rdtgroup_seqfile_show, 319 319 - }; 320 320 - 321 321 - static const struct kernfs_ops kf_mondata_ops = { 322 322 - .atomic_write_len = PAGE_SIZE, 323 323 - .seq_show = rdtgroup_mondata_show, 324 324 - }; 325 325 - 326 326 - static bool is_cpu_list(struct kernfs_open_file *of) 327 327 - { 328 328 - struct rftype *rft = of->kn->priv; 329 329 - 330 330 - return rft->flags & RFTYPE_FLAGS_CPUS_LIST; 331 331 - } 332 332 - 333 333 - static int rdtgroup_cpus_show(struct kernfs_open_file *of, 334 334 - struct seq_file *s, void *v) 335 335 - { 336 336 - struct rdtgroup *rdtgrp; 337 337 - struct cpumask *mask; 338 338 - int ret = 0; 339 339 - 340 340 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 341 341 - 342 342 - if (rdtgrp) { 343 343 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 344 344 - if (!rdtgrp->plr->d) { 345 345 - rdt_last_cmd_clear(); 346 346 - rdt_last_cmd_puts("Cache domain offline\n"); 347 347 - ret = -ENODEV; 348 348 - } else { 349 349 - mask = &rdtgrp->plr->d->hdr.cpu_mask; 350 350 - seq_printf(s, is_cpu_list(of) ? 351 351 - "%*pbl\n" : "%*pb\n", 352 352 - cpumask_pr_args(mask)); 353 353 - } 354 354 - } else { 355 355 - seq_printf(s, is_cpu_list(of) ? "%*pbl\n" : "%*pb\n", 356 356 - cpumask_pr_args(&rdtgrp->cpu_mask)); 357 357 - } 358 358 - } else { 359 359 - ret = -ENOENT; 360 360 - } 361 361 - rdtgroup_kn_unlock(of->kn); 362 362 - 363 363 - return ret; 364 364 - } 365 365 - 366 366 - /* 367 367 - * This is safe against resctrl_sched_in() called from __switch_to() 41 41 + * This is safe against resctrl_arch_sched_in() called from __switch_to() 368 42 * because __switch_to() is executed with interrupts disabled. A local call 369 43 * from update_closid_rmid() is protected against __switch_to() because 370 44 * preemption is disabled. ··· 58 382 * executing task might have its own closid selected. Just reuse 59 383 * the context switch code. 60 384 */ 61 61 - resctrl_sched_in(current); 62 62 - } 63 63 - 64 64 - /* 65 65 - * Update the PGR_ASSOC MSR on all cpus in @cpu_mask, 66 66 - * 67 67 - * Per task closids/rmids must have been set up before calling this function. 68 68 - * @r may be NULL. 69 69 - */ 70 70 - static void 71 71 - update_closid_rmid(const struct cpumask *cpu_mask, struct rdtgroup *r) 72 72 - { 73 73 - struct resctrl_cpu_defaults defaults, *p = NULL; 74 74 - 75 75 - if (r) { 76 76 - defaults.closid = r->closid; 77 77 - defaults.rmid = r->mon.rmid; 78 78 - p = &defaults; 79 79 - } 80 80 - 81 81 - on_each_cpu_mask(cpu_mask, resctrl_arch_sync_cpu_closid_rmid, p, 1); 82 82 - } 83 83 - 84 84 - static int cpus_mon_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 85 85 - cpumask_var_t tmpmask) 86 86 - { 87 87 - struct rdtgroup *prgrp = rdtgrp->mon.parent, *crgrp; 88 88 - struct list_head *head; 89 89 - 90 90 - /* Check whether cpus belong to parent ctrl group */ 91 91 - cpumask_andnot(tmpmask, newmask, &prgrp->cpu_mask); 92 92 - if (!cpumask_empty(tmpmask)) { 93 93 - rdt_last_cmd_puts("Can only add CPUs to mongroup that belong to parent\n"); 94 94 - return -EINVAL; 95 95 - } 96 96 - 97 97 - /* Check whether cpus are dropped from this group */ 98 98 - cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 99 99 - if (!cpumask_empty(tmpmask)) { 100 100 - /* Give any dropped cpus to parent rdtgroup */ 101 101 - cpumask_or(&prgrp->cpu_mask, &prgrp->cpu_mask, tmpmask); 102 102 - update_closid_rmid(tmpmask, prgrp); 103 103 - } 104 104 - 105 105 - /* 106 106 - * If we added cpus, remove them from previous group that owned them 107 107 - * and update per-cpu rmid 108 108 - */ 109 109 - cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 110 110 - if (!cpumask_empty(tmpmask)) { 111 111 - head = &prgrp->mon.crdtgrp_list; 112 112 - list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 113 113 - if (crgrp == rdtgrp) 114 114 - continue; 115 115 - cpumask_andnot(&crgrp->cpu_mask, &crgrp->cpu_mask, 116 116 - tmpmask); 117 117 - } 118 118 - update_closid_rmid(tmpmask, rdtgrp); 119 119 - } 120 120 - 121 121 - /* Done pushing/pulling - update this group with new mask */ 122 122 - cpumask_copy(&rdtgrp->cpu_mask, newmask); 123 123 - 124 124 - return 0; 125 125 - } 126 126 - 127 127 - static void cpumask_rdtgrp_clear(struct rdtgroup *r, struct cpumask *m) 128 128 - { 129 129 - struct rdtgroup *crgrp; 130 130 - 131 131 - cpumask_andnot(&r->cpu_mask, &r->cpu_mask, m); 132 132 - /* update the child mon group masks as well*/ 133 133 - list_for_each_entry(crgrp, &r->mon.crdtgrp_list, mon.crdtgrp_list) 134 134 - cpumask_and(&crgrp->cpu_mask, &r->cpu_mask, &crgrp->cpu_mask); 135 135 - } 136 136 - 137 137 - static int cpus_ctrl_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 138 138 - cpumask_var_t tmpmask, cpumask_var_t tmpmask1) 139 139 - { 140 140 - struct rdtgroup *r, *crgrp; 141 141 - struct list_head *head; 142 142 - 143 143 - /* Check whether cpus are dropped from this group */ 144 144 - cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 145 145 - if (!cpumask_empty(tmpmask)) { 146 146 - /* Can't drop from default group */ 147 147 - if (rdtgrp == &rdtgroup_default) { 148 148 - rdt_last_cmd_puts("Can't drop CPUs from default group\n"); 149 149 - return -EINVAL; 150 150 - } 151 151 - 152 152 - /* Give any dropped cpus to rdtgroup_default */ 153 153 - cpumask_or(&rdtgroup_default.cpu_mask, 154 154 - &rdtgroup_default.cpu_mask, tmpmask); 155 155 - update_closid_rmid(tmpmask, &rdtgroup_default); 156 156 - } 157 157 - 158 158 - /* 159 159 - * If we added cpus, remove them from previous group and 160 160 - * the prev group's child groups that owned them 161 161 - * and update per-cpu closid/rmid. 162 162 - */ 163 163 - cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 164 164 - if (!cpumask_empty(tmpmask)) { 165 165 - list_for_each_entry(r, &rdt_all_groups, rdtgroup_list) { 166 166 - if (r == rdtgrp) 167 167 - continue; 168 168 - cpumask_and(tmpmask1, &r->cpu_mask, tmpmask); 169 169 - if (!cpumask_empty(tmpmask1)) 170 170 - cpumask_rdtgrp_clear(r, tmpmask1); 171 171 - } 172 172 - update_closid_rmid(tmpmask, rdtgrp); 173 173 - } 174 174 - 175 175 - /* Done pushing/pulling - update this group with new mask */ 176 176 - cpumask_copy(&rdtgrp->cpu_mask, newmask); 177 177 - 178 178 - /* 179 179 - * Clear child mon group masks since there is a new parent mask 180 180 - * now and update the rmid for the cpus the child lost. 181 181 - */ 182 182 - head = &rdtgrp->mon.crdtgrp_list; 183 183 - list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 184 184 - cpumask_and(tmpmask, &rdtgrp->cpu_mask, &crgrp->cpu_mask); 185 185 - update_closid_rmid(tmpmask, rdtgrp); 186 186 - cpumask_clear(&crgrp->cpu_mask); 187 187 - } 188 188 - 189 189 - return 0; 190 190 - } 191 191 - 192 192 - static ssize_t rdtgroup_cpus_write(struct kernfs_open_file *of, 193 193 - char *buf, size_t nbytes, loff_t off) 194 194 - { 195 195 - cpumask_var_t tmpmask, newmask, tmpmask1; 196 196 - struct rdtgroup *rdtgrp; 197 197 - int ret; 198 198 - 199 199 - if (!buf) 200 200 - return -EINVAL; 201 201 - 202 202 - if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 203 203 - return -ENOMEM; 204 204 - if (!zalloc_cpumask_var(&newmask, GFP_KERNEL)) { 205 205 - free_cpumask_var(tmpmask); 206 206 - return -ENOMEM; 207 207 - } 208 208 - if (!zalloc_cpumask_var(&tmpmask1, GFP_KERNEL)) { 209 209 - free_cpumask_var(tmpmask); 210 210 - free_cpumask_var(newmask); 211 211 - return -ENOMEM; 212 212 - } 213 213 - 214 214 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 215 215 - if (!rdtgrp) { 216 216 - ret = -ENOENT; 217 217 - goto unlock; 218 218 - } 219 219 - 220 220 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 221 221 - rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 222 222 - ret = -EINVAL; 223 223 - rdt_last_cmd_puts("Pseudo-locking in progress\n"); 224 224 - goto unlock; 225 225 - } 226 226 - 227 227 - if (is_cpu_list(of)) 228 228 - ret = cpulist_parse(buf, newmask); 229 229 - else 230 230 - ret = cpumask_parse(buf, newmask); 231 231 - 232 232 - if (ret) { 233 233 - rdt_last_cmd_puts("Bad CPU list/mask\n"); 234 234 - goto unlock; 235 235 - } 236 236 - 237 237 - /* check that user didn't specify any offline cpus */ 238 238 - cpumask_andnot(tmpmask, newmask, cpu_online_mask); 239 239 - if (!cpumask_empty(tmpmask)) { 240 240 - ret = -EINVAL; 241 241 - rdt_last_cmd_puts("Can only assign online CPUs\n"); 242 242 - goto unlock; 243 243 - } 244 244 - 245 245 - if (rdtgrp->type == RDTCTRL_GROUP) 246 246 - ret = cpus_ctrl_write(rdtgrp, newmask, tmpmask, tmpmask1); 247 247 - else if (rdtgrp->type == RDTMON_GROUP) 248 248 - ret = cpus_mon_write(rdtgrp, newmask, tmpmask); 249 249 - else 250 250 - ret = -EINVAL; 251 251 - 252 252 - unlock: 253 253 - rdtgroup_kn_unlock(of->kn); 254 254 - free_cpumask_var(tmpmask); 255 255 - free_cpumask_var(newmask); 256 256 - free_cpumask_var(tmpmask1); 257 257 - 258 258 - return ret ?: nbytes; 259 259 - } 260 260 - 261 261 - /** 262 262 - * rdtgroup_remove - the helper to remove resource group safely 263 263 - * @rdtgrp: resource group to remove 264 264 - * 265 265 - * On resource group creation via a mkdir, an extra kernfs_node reference is 266 266 - * taken to ensure that the rdtgroup structure remains accessible for the 267 267 - * rdtgroup_kn_unlock() calls where it is removed. 268 268 - * 269 269 - * Drop the extra reference here, then free the rdtgroup structure. 270 270 - * 271 271 - * Return: void 272 272 - */ 273 273 - static void rdtgroup_remove(struct rdtgroup *rdtgrp) 274 274 - { 275 275 - kernfs_put(rdtgrp->kn); 276 276 - kfree(rdtgrp); 277 277 - } 278 278 - 279 279 - static void _update_task_closid_rmid(void *task) 280 280 - { 281 281 - /* 282 282 - * If the task is still current on this CPU, update PQR_ASSOC MSR. 283 283 - * Otherwise, the MSR is updated when the task is scheduled in. 284 284 - */ 285 285 - if (task == current) 286 286 - resctrl_sched_in(task); 287 287 - } 288 288 - 289 289 - static void update_task_closid_rmid(struct task_struct *t) 290 290 - { 291 291 - if (IS_ENABLED(CONFIG_SMP) && task_curr(t)) 292 292 - smp_call_function_single(task_cpu(t), _update_task_closid_rmid, t, 1); 293 293 - else 294 294 - _update_task_closid_rmid(t); 295 295 - } 296 296 - 297 297 - static bool task_in_rdtgroup(struct task_struct *tsk, struct rdtgroup *rdtgrp) 298 298 - { 299 299 - u32 closid, rmid = rdtgrp->mon.rmid; 300 300 - 301 301 - if (rdtgrp->type == RDTCTRL_GROUP) 302 302 - closid = rdtgrp->closid; 303 303 - else if (rdtgrp->type == RDTMON_GROUP) 304 304 - closid = rdtgrp->mon.parent->closid; 305 305 - else 306 306 - return false; 307 307 - 308 308 - return resctrl_arch_match_closid(tsk, closid) && 309 309 - resctrl_arch_match_rmid(tsk, closid, rmid); 310 310 - } 311 311 - 312 312 - static int __rdtgroup_move_task(struct task_struct *tsk, 313 313 - struct rdtgroup *rdtgrp) 314 314 - { 315 315 - /* If the task is already in rdtgrp, no need to move the task. */ 316 316 - if (task_in_rdtgroup(tsk, rdtgrp)) 317 317 - return 0; 318 318 - 319 319 - /* 320 320 - * Set the task's closid/rmid before the PQR_ASSOC MSR can be 321 321 - * updated by them. 322 322 - * 323 323 - * For ctrl_mon groups, move both closid and rmid. 324 324 - * For monitor groups, can move the tasks only from 325 325 - * their parent CTRL group. 326 326 - */ 327 327 - if (rdtgrp->type == RDTMON_GROUP && 328 328 - !resctrl_arch_match_closid(tsk, rdtgrp->mon.parent->closid)) { 329 329 - rdt_last_cmd_puts("Can't move task to different control group\n"); 330 330 - return -EINVAL; 331 331 - } 332 332 - 333 333 - if (rdtgrp->type == RDTMON_GROUP) 334 334 - resctrl_arch_set_closid_rmid(tsk, rdtgrp->mon.parent->closid, 335 335 - rdtgrp->mon.rmid); 336 336 - else 337 337 - resctrl_arch_set_closid_rmid(tsk, rdtgrp->closid, 338 338 - rdtgrp->mon.rmid); 339 339 - 340 340 - /* 341 341 - * Ensure the task's closid and rmid are written before determining if 342 342 - * the task is current that will decide if it will be interrupted. 343 343 - * This pairs with the full barrier between the rq->curr update and 344 344 - * resctrl_sched_in() during context switch. 345 345 - */ 346 346 - smp_mb(); 347 347 - 348 348 - /* 349 349 - * By now, the task's closid and rmid are set. If the task is current 350 350 - * on a CPU, the PQR_ASSOC MSR needs to be updated to make the resource 351 351 - * group go into effect. If the task is not current, the MSR will be 352 352 - * updated when the task is scheduled in. 353 353 - */ 354 354 - update_task_closid_rmid(tsk); 355 355 - 356 356 - return 0; 357 357 - } 358 358 - 359 359 - static bool is_closid_match(struct task_struct *t, struct rdtgroup *r) 360 360 - { 361 361 - return (resctrl_arch_alloc_capable() && (r->type == RDTCTRL_GROUP) && 362 362 - resctrl_arch_match_closid(t, r->closid)); 363 363 - } 364 364 - 365 365 - static bool is_rmid_match(struct task_struct *t, struct rdtgroup *r) 366 366 - { 367 367 - return (resctrl_arch_mon_capable() && (r->type == RDTMON_GROUP) && 368 368 - resctrl_arch_match_rmid(t, r->mon.parent->closid, 369 369 - r->mon.rmid)); 370 370 - } 371 371 - 372 372 - /** 373 373 - * rdtgroup_tasks_assigned - Test if tasks have been assigned to resource group 374 374 - * @r: Resource group 375 375 - * 376 376 - * Return: 1 if tasks have been assigned to @r, 0 otherwise 377 377 - */ 378 378 - int rdtgroup_tasks_assigned(struct rdtgroup *r) 379 379 - { 380 380 - struct task_struct *p, *t; 381 381 - int ret = 0; 382 382 - 383 383 - lockdep_assert_held(&rdtgroup_mutex); 384 384 - 385 385 - rcu_read_lock(); 386 386 - for_each_process_thread(p, t) { 387 387 - if (is_closid_match(t, r) || is_rmid_match(t, r)) { 388 388 - ret = 1; 389 389 - break; 390 390 - } 391 391 - } 392 392 - rcu_read_unlock(); 393 393 - 394 394 - return ret; 395 395 - } 396 396 - 397 397 - static int rdtgroup_task_write_permission(struct task_struct *task, 398 398 - struct kernfs_open_file *of) 399 399 - { 400 400 - const struct cred *tcred = get_task_cred(task); 401 401 - const struct cred *cred = current_cred(); 402 402 - int ret = 0; 403 403 - 404 404 - /* 405 405 - * Even if we're attaching all tasks in the thread group, we only 406 406 - * need to check permissions on one of them. 407 407 - */ 408 408 - if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) && 409 409 - !uid_eq(cred->euid, tcred->uid) && 410 410 - !uid_eq(cred->euid, tcred->suid)) { 411 411 - rdt_last_cmd_printf("No permission to move task %d\n", task->pid); 412 412 - ret = -EPERM; 413 413 - } 414 414 - 415 415 - put_cred(tcred); 416 416 - return ret; 417 417 - } 418 418 - 419 419 - static int rdtgroup_move_task(pid_t pid, struct rdtgroup *rdtgrp, 420 420 - struct kernfs_open_file *of) 421 421 - { 422 422 - struct task_struct *tsk; 423 423 - int ret; 424 424 - 425 425 - rcu_read_lock(); 426 426 - if (pid) { 427 427 - tsk = find_task_by_vpid(pid); 428 428 - if (!tsk) { 429 429 - rcu_read_unlock(); 430 430 - rdt_last_cmd_printf("No task %d\n", pid); 431 431 - return -ESRCH; 432 432 - } 433 433 - } else { 434 434 - tsk = current; 435 435 - } 436 436 - 437 437 - get_task_struct(tsk); 438 438 - rcu_read_unlock(); 439 439 - 440 440 - ret = rdtgroup_task_write_permission(tsk, of); 441 441 - if (!ret) 442 442 - ret = __rdtgroup_move_task(tsk, rdtgrp); 443 443 - 444 444 - put_task_struct(tsk); 445 445 - return ret; 446 446 - } 447 447 - 448 448 - static ssize_t rdtgroup_tasks_write(struct kernfs_open_file *of, 449 449 - char *buf, size_t nbytes, loff_t off) 450 450 - { 451 451 - struct rdtgroup *rdtgrp; 452 452 - char *pid_str; 453 453 - int ret = 0; 454 454 - pid_t pid; 455 455 - 456 456 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 457 457 - if (!rdtgrp) { 458 458 - rdtgroup_kn_unlock(of->kn); 459 459 - return -ENOENT; 460 460 - } 461 461 - rdt_last_cmd_clear(); 462 462 - 463 463 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 464 464 - rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 465 465 - ret = -EINVAL; 466 466 - rdt_last_cmd_puts("Pseudo-locking in progress\n"); 467 467 - goto unlock; 468 468 - } 469 469 - 470 470 - while (buf && buf[0] != '\0' && buf[0] != '\n') { 471 471 - pid_str = strim(strsep(&buf, ",")); 472 472 - 473 473 - if (kstrtoint(pid_str, 0, &pid)) { 474 474 - rdt_last_cmd_printf("Task list parsing error pid %s\n", pid_str); 475 475 - ret = -EINVAL; 476 476 - break; 477 477 - } 478 478 - 479 479 - if (pid < 0) { 480 480 - rdt_last_cmd_printf("Invalid pid %d\n", pid); 481 481 - ret = -EINVAL; 482 482 - break; 483 483 - } 484 484 - 485 485 - ret = rdtgroup_move_task(pid, rdtgrp, of); 486 486 - if (ret) { 487 487 - rdt_last_cmd_printf("Error while processing task %d\n", pid); 488 488 - break; 489 489 - } 490 490 - } 491 491 - 492 492 - unlock: 493 493 - rdtgroup_kn_unlock(of->kn); 494 494 - 495 495 - return ret ?: nbytes; 496 496 - } 497 497 - 498 498 - static void show_rdt_tasks(struct rdtgroup *r, struct seq_file *s) 499 499 - { 500 500 - struct task_struct *p, *t; 501 501 - pid_t pid; 502 502 - 503 503 - rcu_read_lock(); 504 504 - for_each_process_thread(p, t) { 505 505 - if (is_closid_match(t, r) || is_rmid_match(t, r)) { 506 506 - pid = task_pid_vnr(t); 507 507 - if (pid) 508 508 - seq_printf(s, "%d\n", pid); 509 509 - } 510 510 - } 511 511 - rcu_read_unlock(); 512 512 - } 513 513 - 514 514 - static int rdtgroup_tasks_show(struct kernfs_open_file *of, 515 515 - struct seq_file *s, void *v) 516 516 - { 517 517 - struct rdtgroup *rdtgrp; 518 518 - int ret = 0; 519 519 - 520 520 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 521 521 - if (rdtgrp) 522 522 - show_rdt_tasks(rdtgrp, s); 523 523 - else 524 524 - ret = -ENOENT; 525 525 - rdtgroup_kn_unlock(of->kn); 526 526 - 527 527 - return ret; 528 528 - } 529 529 - 530 530 - static int rdtgroup_closid_show(struct kernfs_open_file *of, 531 531 - struct seq_file *s, void *v) 532 532 - { 533 533 - struct rdtgroup *rdtgrp; 534 534 - int ret = 0; 535 535 - 536 536 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 537 537 - if (rdtgrp) 538 538 - seq_printf(s, "%u\n", rdtgrp->closid); 539 539 - else 540 540 - ret = -ENOENT; 541 541 - rdtgroup_kn_unlock(of->kn); 542 542 - 543 543 - return ret; 544 544 - } 545 545 - 546 546 - static int rdtgroup_rmid_show(struct kernfs_open_file *of, 547 547 - struct seq_file *s, void *v) 548 548 - { 549 549 - struct rdtgroup *rdtgrp; 550 550 - int ret = 0; 551 551 - 552 552 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 553 553 - if (rdtgrp) 554 554 - seq_printf(s, "%u\n", rdtgrp->mon.rmid); 555 555 - else 556 556 - ret = -ENOENT; 557 557 - rdtgroup_kn_unlock(of->kn); 558 558 - 559 559 - return ret; 560 560 - } 561 561 - 562 562 - #ifdef CONFIG_PROC_CPU_RESCTRL 563 563 - 564 564 - /* 565 565 - * A task can only be part of one resctrl control group and of one monitor 566 566 - * group which is associated to that control group. 567 567 - * 568 568 - * 1) res: 569 569 - * mon: 570 570 - * 571 571 - * resctrl is not available. 572 572 - * 573 573 - * 2) res:/ 574 574 - * mon: 575 575 - * 576 576 - * Task is part of the root resctrl control group, and it is not associated 577 577 - * to any monitor group. 578 578 - * 579 579 - * 3) res:/ 580 580 - * mon:mon0 581 581 - * 582 582 - * Task is part of the root resctrl control group and monitor group mon0. 583 583 - * 584 584 - * 4) res:group0 585 585 - * mon: 586 586 - * 587 587 - * Task is part of resctrl control group group0, and it is not associated 588 588 - * to any monitor group. 589 589 - * 590 590 - * 5) res:group0 591 591 - * mon:mon1 592 592 - * 593 593 - * Task is part of resctrl control group group0 and monitor group mon1. 594 594 - */ 595 595 - int proc_resctrl_show(struct seq_file *s, struct pid_namespace *ns, 596 596 - struct pid *pid, struct task_struct *tsk) 597 597 - { 598 598 - struct rdtgroup *rdtg; 599 599 - int ret = 0; 600 600 - 601 601 - mutex_lock(&rdtgroup_mutex); 602 602 - 603 603 - /* Return empty if resctrl has not been mounted. */ 604 604 - if (!resctrl_mounted) { 605 605 - seq_puts(s, "res:\nmon:\n"); 606 606 - goto unlock; 607 607 - } 608 608 - 609 609 - list_for_each_entry(rdtg, &rdt_all_groups, rdtgroup_list) { 610 610 - struct rdtgroup *crg; 611 611 - 612 612 - /* 613 613 - * Task information is only relevant for shareable 614 614 - * and exclusive groups. 615 615 - */ 616 616 - if (rdtg->mode != RDT_MODE_SHAREABLE && 617 617 - rdtg->mode != RDT_MODE_EXCLUSIVE) 618 618 - continue; 619 619 - 620 620 - if (!resctrl_arch_match_closid(tsk, rdtg->closid)) 621 621 - continue; 622 622 - 623 623 - seq_printf(s, "res:%s%s\n", (rdtg == &rdtgroup_default) ? "/" : "", 624 624 - rdt_kn_name(rdtg->kn)); 625 625 - seq_puts(s, "mon:"); 626 626 - list_for_each_entry(crg, &rdtg->mon.crdtgrp_list, 627 627 - mon.crdtgrp_list) { 628 628 - if (!resctrl_arch_match_rmid(tsk, crg->mon.parent->closid, 629 629 - crg->mon.rmid)) 630 630 - continue; 631 631 - seq_printf(s, "%s", rdt_kn_name(crg->kn)); 632 632 - break; 633 633 - } 634 634 - seq_putc(s, '\n'); 635 635 - goto unlock; 636 636 - } 637 637 - /* 638 638 - * The above search should succeed. Otherwise return 639 639 - * with an error. 640 640 - */ 641 641 - ret = -ENOENT; 642 642 - unlock: 643 643 - mutex_unlock(&rdtgroup_mutex); 644 644 - 645 645 - return ret; 646 646 - } 647 647 - #endif 648 648 - 649 649 - static int rdt_last_cmd_status_show(struct kernfs_open_file *of, 650 650 - struct seq_file *seq, void *v) 651 651 - { 652 652 - int len; 653 653 - 654 654 - mutex_lock(&rdtgroup_mutex); 655 655 - len = seq_buf_used(&last_cmd_status); 656 656 - if (len) 657 657 - seq_printf(seq, "%.*s", len, last_cmd_status_buf); 658 658 - else 659 659 - seq_puts(seq, "ok\n"); 660 660 - mutex_unlock(&rdtgroup_mutex); 661 661 - return 0; 662 662 - } 663 663 - 664 664 - static void *rdt_kn_parent_priv(struct kernfs_node *kn) 665 665 - { 666 666 - /* 667 667 - * The parent pointer is only valid within RCU section since it can be 668 668 - * replaced. 669 669 - */ 670 670 - guard(rcu)(); 671 671 - return rcu_dereference(kn->__parent)->priv; 672 672 - } 673 673 - 674 674 - static int rdt_num_closids_show(struct kernfs_open_file *of, 675 675 - struct seq_file *seq, void *v) 676 676 - { 677 677 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 678 678 - 679 679 - seq_printf(seq, "%u\n", s->num_closid); 680 680 - return 0; 681 681 - } 682 682 - 683 683 - static int rdt_default_ctrl_show(struct kernfs_open_file *of, 684 684 - struct seq_file *seq, void *v) 685 685 - { 686 686 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 687 687 - struct rdt_resource *r = s->res; 688 688 - 689 689 - seq_printf(seq, "%x\n", resctrl_get_default_ctrl(r)); 690 690 - return 0; 691 691 - } 692 692 - 693 693 - static int rdt_min_cbm_bits_show(struct kernfs_open_file *of, 694 694 - struct seq_file *seq, void *v) 695 695 - { 696 696 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 697 697 - struct rdt_resource *r = s->res; 698 698 - 699 699 - seq_printf(seq, "%u\n", r->cache.min_cbm_bits); 700 700 - return 0; 701 701 - } 702 702 - 703 703 - static int rdt_shareable_bits_show(struct kernfs_open_file *of, 704 704 - struct seq_file *seq, void *v) 705 705 - { 706 706 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 707 707 - struct rdt_resource *r = s->res; 708 708 - 709 709 - seq_printf(seq, "%x\n", r->cache.shareable_bits); 710 710 - return 0; 711 711 - } 712 712 - 713 713 - /* 714 714 - * rdt_bit_usage_show - Display current usage of resources 715 715 - * 716 716 - * A domain is a shared resource that can now be allocated differently. Here 717 717 - * we display the current regions of the domain as an annotated bitmask. 718 718 - * For each domain of this resource its allocation bitmask 719 719 - * is annotated as below to indicate the current usage of the corresponding bit: 720 720 - * 0 - currently unused 721 721 - * X - currently available for sharing and used by software and hardware 722 722 - * H - currently used by hardware only but available for software use 723 723 - * S - currently used and shareable by software only 724 724 - * E - currently used exclusively by one resource group 725 725 - * P - currently pseudo-locked by one resource group 726 726 - */ 727 727 - static int rdt_bit_usage_show(struct kernfs_open_file *of, 728 728 - struct seq_file *seq, void *v) 729 729 - { 730 730 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 731 731 - /* 732 732 - * Use unsigned long even though only 32 bits are used to ensure 733 733 - * test_bit() is used safely. 734 734 - */ 735 735 - unsigned long sw_shareable = 0, hw_shareable = 0; 736 736 - unsigned long exclusive = 0, pseudo_locked = 0; 737 737 - struct rdt_resource *r = s->res; 738 738 - struct rdt_ctrl_domain *dom; 739 739 - int i, hwb, swb, excl, psl; 740 740 - enum rdtgrp_mode mode; 741 741 - bool sep = false; 742 742 - u32 ctrl_val; 743 743 - 744 744 - cpus_read_lock(); 745 745 - mutex_lock(&rdtgroup_mutex); 746 746 - hw_shareable = r->cache.shareable_bits; 747 747 - list_for_each_entry(dom, &r->ctrl_domains, hdr.list) { 748 748 - if (sep) 749 749 - seq_putc(seq, ';'); 750 750 - sw_shareable = 0; 751 751 - exclusive = 0; 752 752 - seq_printf(seq, "%d=", dom->hdr.id); 753 753 - for (i = 0; i < closids_supported(); i++) { 754 754 - if (!closid_allocated(i)) 755 755 - continue; 756 756 - ctrl_val = resctrl_arch_get_config(r, dom, i, 757 757 - s->conf_type); 758 758 - mode = rdtgroup_mode_by_closid(i); 759 759 - switch (mode) { 760 760 - case RDT_MODE_SHAREABLE: 761 761 - sw_shareable |= ctrl_val; 762 762 - break; 763 763 - case RDT_MODE_EXCLUSIVE: 764 764 - exclusive |= ctrl_val; 765 765 - break; 766 766 - case RDT_MODE_PSEUDO_LOCKSETUP: 767 767 - /* 768 768 - * RDT_MODE_PSEUDO_LOCKSETUP is possible 769 769 - * here but not included since the CBM 770 770 - * associated with this CLOSID in this mode 771 771 - * is not initialized and no task or cpu can be 772 772 - * assigned this CLOSID. 773 773 - */ 774 774 - break; 775 775 - case RDT_MODE_PSEUDO_LOCKED: 776 776 - case RDT_NUM_MODES: 777 777 - WARN(1, 778 778 - "invalid mode for closid %d\n", i); 779 779 - break; 780 780 - } 781 781 - } 782 782 - for (i = r->cache.cbm_len - 1; i >= 0; i--) { 783 783 - pseudo_locked = dom->plr ? dom->plr->cbm : 0; 784 784 - hwb = test_bit(i, &hw_shareable); 785 785 - swb = test_bit(i, &sw_shareable); 786 786 - excl = test_bit(i, &exclusive); 787 787 - psl = test_bit(i, &pseudo_locked); 788 788 - if (hwb && swb) 789 789 - seq_putc(seq, 'X'); 790 790 - else if (hwb && !swb) 791 791 - seq_putc(seq, 'H'); 792 792 - else if (!hwb && swb) 793 793 - seq_putc(seq, 'S'); 794 794 - else if (excl) 795 795 - seq_putc(seq, 'E'); 796 796 - else if (psl) 797 797 - seq_putc(seq, 'P'); 798 798 - else /* Unused bits remain */ 799 799 - seq_putc(seq, '0'); 800 800 - } 801 801 - sep = true; 802 802 - } 803 803 - seq_putc(seq, '\n'); 804 804 - mutex_unlock(&rdtgroup_mutex); 805 805 - cpus_read_unlock(); 806 806 - return 0; 807 807 - } 808 808 - 809 809 - static int rdt_min_bw_show(struct kernfs_open_file *of, 810 810 - struct seq_file *seq, void *v) 811 811 - { 812 812 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 813 813 - struct rdt_resource *r = s->res; 814 814 - 815 815 - seq_printf(seq, "%u\n", r->membw.min_bw); 816 816 - return 0; 817 817 - } 818 818 - 819 819 - static int rdt_num_rmids_show(struct kernfs_open_file *of, 820 820 - struct seq_file *seq, void *v) 821 821 - { 822 822 - struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 823 823 - 824 824 - seq_printf(seq, "%d\n", r->num_rmid); 825 825 - 826 826 - return 0; 827 827 - } 828 828 - 829 829 - static int rdt_mon_features_show(struct kernfs_open_file *of, 830 830 - struct seq_file *seq, void *v) 831 831 - { 832 832 - struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 833 833 - struct mon_evt *mevt; 834 834 - 835 835 - list_for_each_entry(mevt, &r->evt_list, list) { 836 836 - seq_printf(seq, "%s\n", mevt->name); 837 837 - if (mevt->configurable) 838 838 - seq_printf(seq, "%s_config\n", mevt->name); 839 839 - } 840 840 - 841 841 - return 0; 842 842 - } 843 843 - 844 844 - static int rdt_bw_gran_show(struct kernfs_open_file *of, 845 845 - struct seq_file *seq, void *v) 846 846 - { 847 847 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 848 848 - struct rdt_resource *r = s->res; 849 849 - 850 850 - seq_printf(seq, "%u\n", r->membw.bw_gran); 851 851 - return 0; 852 852 - } 853 853 - 854 854 - static int rdt_delay_linear_show(struct kernfs_open_file *of, 855 855 - struct seq_file *seq, void *v) 856 856 - { 857 857 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 858 858 - struct rdt_resource *r = s->res; 859 859 - 860 860 - seq_printf(seq, "%u\n", r->membw.delay_linear); 861 861 - return 0; 862 862 - } 863 863 - 864 864 - static int max_threshold_occ_show(struct kernfs_open_file *of, 865 865 - struct seq_file *seq, void *v) 866 866 - { 867 867 - seq_printf(seq, "%u\n", resctrl_rmid_realloc_threshold); 868 868 - 869 869 - return 0; 870 870 - } 871 871 - 872 872 - static int rdt_thread_throttle_mode_show(struct kernfs_open_file *of, 873 873 - struct seq_file *seq, void *v) 874 874 - { 875 875 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 876 876 - struct rdt_resource *r = s->res; 877 877 - 878 878 - switch (r->membw.throttle_mode) { 879 879 - case THREAD_THROTTLE_PER_THREAD: 880 880 - seq_puts(seq, "per-thread\n"); 881 881 - return 0; 882 882 - case THREAD_THROTTLE_MAX: 883 883 - seq_puts(seq, "max\n"); 884 884 - return 0; 885 885 - case THREAD_THROTTLE_UNDEFINED: 886 886 - seq_puts(seq, "undefined\n"); 887 887 - return 0; 888 888 - } 889 889 - 890 890 - WARN_ON_ONCE(1); 891 891 - 892 892 - return 0; 893 893 - } 894 894 - 895 895 - static ssize_t max_threshold_occ_write(struct kernfs_open_file *of, 896 896 - char *buf, size_t nbytes, loff_t off) 897 897 - { 898 898 - unsigned int bytes; 899 899 - int ret; 900 900 - 901 901 - ret = kstrtouint(buf, 0, &bytes); 902 902 - if (ret) 903 903 - return ret; 904 904 - 905 905 - if (bytes > resctrl_rmid_realloc_limit) 906 906 - return -EINVAL; 907 907 - 908 908 - resctrl_rmid_realloc_threshold = resctrl_arch_round_mon_val(bytes); 909 909 - 910 910 - return nbytes; 911 911 - } 912 912 - 913 913 - /* 914 914 - * rdtgroup_mode_show - Display mode of this resource group 915 915 - */ 916 916 - static int rdtgroup_mode_show(struct kernfs_open_file *of, 917 917 - struct seq_file *s, void *v) 918 918 - { 919 919 - struct rdtgroup *rdtgrp; 920 920 - 921 921 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 922 922 - if (!rdtgrp) { 923 923 - rdtgroup_kn_unlock(of->kn); 924 924 - return -ENOENT; 925 925 - } 926 926 - 927 927 - seq_printf(s, "%s\n", rdtgroup_mode_str(rdtgrp->mode)); 928 928 - 929 929 - rdtgroup_kn_unlock(of->kn); 930 930 - return 0; 931 931 - } 932 932 - 933 933 - static enum resctrl_conf_type resctrl_peer_type(enum resctrl_conf_type my_type) 934 934 - { 935 935 - switch (my_type) { 936 936 - case CDP_CODE: 937 937 - return CDP_DATA; 938 938 - case CDP_DATA: 939 939 - return CDP_CODE; 940 940 - default: 941 941 - case CDP_NONE: 942 942 - return CDP_NONE; 943 943 - } 944 944 - } 945 945 - 946 946 - static int rdt_has_sparse_bitmasks_show(struct kernfs_open_file *of, 947 947 - struct seq_file *seq, void *v) 948 948 - { 949 949 - struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 950 950 - struct rdt_resource *r = s->res; 951 951 - 952 952 - seq_printf(seq, "%u\n", r->cache.arch_has_sparse_bitmasks); 953 953 - 954 954 - return 0; 955 955 - } 956 956 - 957 957 - /** 958 958 - * __rdtgroup_cbm_overlaps - Does CBM for intended closid overlap with other 959 959 - * @r: Resource to which domain instance @d belongs. 960 960 - * @d: The domain instance for which @closid is being tested. 961 961 - * @cbm: Capacity bitmask being tested. 962 962 - * @closid: Intended closid for @cbm. 963 963 - * @type: CDP type of @r. 964 964 - * @exclusive: Only check if overlaps with exclusive resource groups 965 965 - * 966 966 - * Checks if provided @cbm intended to be used for @closid on domain 967 967 - * @d overlaps with any other closids or other hardware usage associated 968 968 - * with this domain. If @exclusive is true then only overlaps with 969 969 - * resource groups in exclusive mode will be considered. If @exclusive 970 970 - * is false then overlaps with any resource group or hardware entities 971 971 - * will be considered. 972 972 - * 973 973 - * @cbm is unsigned long, even if only 32 bits are used, to make the 974 974 - * bitmap functions work correctly. 975 975 - * 976 976 - * Return: false if CBM does not overlap, true if it does. 977 977 - */ 978 978 - static bool __rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_ctrl_domain *d, 979 979 - unsigned long cbm, int closid, 980 980 - enum resctrl_conf_type type, bool exclusive) 981 981 - { 982 982 - enum rdtgrp_mode mode; 983 983 - unsigned long ctrl_b; 984 984 - int i; 985 985 - 986 986 - /* Check for any overlap with regions used by hardware directly */ 987 987 - if (!exclusive) { 988 988 - ctrl_b = r->cache.shareable_bits; 989 989 - if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) 990 990 - return true; 991 991 - } 992 992 - 993 993 - /* Check for overlap with other resource groups */ 994 994 - for (i = 0; i < closids_supported(); i++) { 995 995 - ctrl_b = resctrl_arch_get_config(r, d, i, type); 996 996 - mode = rdtgroup_mode_by_closid(i); 997 997 - if (closid_allocated(i) && i != closid && 998 998 - mode != RDT_MODE_PSEUDO_LOCKSETUP) { 999 999 - if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) { 1000 1000 - if (exclusive) { 1001 1001 - if (mode == RDT_MODE_EXCLUSIVE) 1002 1002 - return true; 1003 1003 - continue; 1004 1004 - } 1005 1005 - return true; 1006 1006 - } 1007 1007 - } 1008 1008 - } 1009 1009 - 1010 1010 - return false; 1011 1011 - } 1012 1012 - 1013 1013 - /** 1014 1014 - * rdtgroup_cbm_overlaps - Does CBM overlap with other use of hardware 1015 1015 - * @s: Schema for the resource to which domain instance @d belongs. 1016 1016 - * @d: The domain instance for which @closid is being tested. 1017 1017 - * @cbm: Capacity bitmask being tested. 1018 1018 - * @closid: Intended closid for @cbm. 1019 1019 - * @exclusive: Only check if overlaps with exclusive resource groups 1020 1020 - * 1021 1021 - * Resources that can be allocated using a CBM can use the CBM to control 1022 1022 - * the overlap of these allocations. rdtgroup_cmb_overlaps() is the test 1023 1023 - * for overlap. Overlap test is not limited to the specific resource for 1024 1024 - * which the CBM is intended though - when dealing with CDP resources that 1025 1025 - * share the underlying hardware the overlap check should be performed on 1026 1026 - * the CDP resource sharing the hardware also. 1027 1027 - * 1028 1028 - * Refer to description of __rdtgroup_cbm_overlaps() for the details of the 1029 1029 - * overlap test. 1030 1030 - * 1031 1031 - * Return: true if CBM overlap detected, false if there is no overlap 1032 1032 - */ 1033 1033 - bool rdtgroup_cbm_overlaps(struct resctrl_schema *s, struct rdt_ctrl_domain *d, 1034 1034 - unsigned long cbm, int closid, bool exclusive) 1035 1035 - { 1036 1036 - enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 1037 1037 - struct rdt_resource *r = s->res; 1038 1038 - 1039 1039 - if (__rdtgroup_cbm_overlaps(r, d, cbm, closid, s->conf_type, 1040 1040 - exclusive)) 1041 1041 - return true; 1042 1042 - 1043 1043 - if (!resctrl_arch_get_cdp_enabled(r->rid)) 1044 1044 - return false; 1045 1045 - return __rdtgroup_cbm_overlaps(r, d, cbm, closid, peer_type, exclusive); 1046 1046 - } 1047 1047 - 1048 1048 - /** 1049 1049 - * rdtgroup_mode_test_exclusive - Test if this resource group can be exclusive 1050 1050 - * @rdtgrp: Resource group identified through its closid. 1051 1051 - * 1052 1052 - * An exclusive resource group implies that there should be no sharing of 1053 1053 - * its allocated resources. At the time this group is considered to be 1054 1054 - * exclusive this test can determine if its current schemata supports this 1055 1055 - * setting by testing for overlap with all other resource groups. 1056 1056 - * 1057 1057 - * Return: true if resource group can be exclusive, false if there is overlap 1058 1058 - * with allocations of other resource groups and thus this resource group 1059 1059 - * cannot be exclusive. 1060 1060 - */ 1061 1061 - static bool rdtgroup_mode_test_exclusive(struct rdtgroup *rdtgrp) 1062 1062 - { 1063 1063 - int closid = rdtgrp->closid; 1064 1064 - struct rdt_ctrl_domain *d; 1065 1065 - struct resctrl_schema *s; 1066 1066 - struct rdt_resource *r; 1067 1067 - bool has_cache = false; 1068 1068 - u32 ctrl; 1069 1069 - 1070 1070 - /* Walking r->domains, ensure it can't race with cpuhp */ 1071 1071 - lockdep_assert_cpus_held(); 1072 1072 - 1073 1073 - list_for_each_entry(s, &resctrl_schema_all, list) { 1074 1074 - r = s->res; 1075 1075 - if (r->rid == RDT_RESOURCE_MBA || r->rid == RDT_RESOURCE_SMBA) 1076 1076 - continue; 1077 1077 - has_cache = true; 1078 1078 - list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 1079 1079 - ctrl = resctrl_arch_get_config(r, d, closid, 1080 1080 - s->conf_type); 1081 1081 - if (rdtgroup_cbm_overlaps(s, d, ctrl, closid, false)) { 1082 1082 - rdt_last_cmd_puts("Schemata overlaps\n"); 1083 1083 - return false; 1084 1084 - } 1085 1085 - } 1086 1086 - } 1087 1087 - 1088 1088 - if (!has_cache) { 1089 1089 - rdt_last_cmd_puts("Cannot be exclusive without CAT/CDP\n"); 1090 1090 - return false; 1091 1091 - } 1092 1092 - 1093 1093 - return true; 1094 1094 - } 1095 1095 - 1096 1096 - /* 1097 1097 - * rdtgroup_mode_write - Modify the resource group's mode 1098 1098 - */ 1099 1099 - static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, 1100 1100 - char *buf, size_t nbytes, loff_t off) 1101 1101 - { 1102 1102 - struct rdtgroup *rdtgrp; 1103 1103 - enum rdtgrp_mode mode; 1104 1104 - int ret = 0; 1105 1105 - 1106 1106 - /* Valid input requires a trailing newline */ 1107 1107 - if (nbytes == 0 || buf[nbytes - 1] != '\n') 1108 1108 - return -EINVAL; 1109 1109 - buf[nbytes - 1] = '\0'; 1110 1110 - 1111 1111 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 1112 1112 - if (!rdtgrp) { 1113 1113 - rdtgroup_kn_unlock(of->kn); 1114 1114 - return -ENOENT; 1115 1115 - } 1116 1116 - 1117 1117 - rdt_last_cmd_clear(); 1118 1118 - 1119 1119 - mode = rdtgrp->mode; 1120 1120 - 1121 1121 - if ((!strcmp(buf, "shareable") && mode == RDT_MODE_SHAREABLE) || 1122 1122 - (!strcmp(buf, "exclusive") && mode == RDT_MODE_EXCLUSIVE) || 1123 1123 - (!strcmp(buf, "pseudo-locksetup") && 1124 1124 - mode == RDT_MODE_PSEUDO_LOCKSETUP) || 1125 1125 - (!strcmp(buf, "pseudo-locked") && mode == RDT_MODE_PSEUDO_LOCKED)) 1126 1126 - goto out; 1127 1127 - 1128 1128 - if (mode == RDT_MODE_PSEUDO_LOCKED) { 1129 1129 - rdt_last_cmd_puts("Cannot change pseudo-locked group\n"); 1130 1130 - ret = -EINVAL; 1131 1131 - goto out; 1132 1132 - } 1133 1133 - 1134 1134 - if (!strcmp(buf, "shareable")) { 1135 1135 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1136 1136 - ret = rdtgroup_locksetup_exit(rdtgrp); 1137 1137 - if (ret) 1138 1138 - goto out; 1139 1139 - } 1140 1140 - rdtgrp->mode = RDT_MODE_SHAREABLE; 1141 1141 - } else if (!strcmp(buf, "exclusive")) { 1142 1142 - if (!rdtgroup_mode_test_exclusive(rdtgrp)) { 1143 1143 - ret = -EINVAL; 1144 1144 - goto out; 1145 1145 - } 1146 1146 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1147 1147 - ret = rdtgroup_locksetup_exit(rdtgrp); 1148 1148 - if (ret) 1149 1149 - goto out; 1150 1150 - } 1151 1151 - rdtgrp->mode = RDT_MODE_EXCLUSIVE; 1152 1152 - } else if (IS_ENABLED(CONFIG_RESCTRL_FS_PSEUDO_LOCK) && 1153 1153 - !strcmp(buf, "pseudo-locksetup")) { 1154 1154 - ret = rdtgroup_locksetup_enter(rdtgrp); 1155 1155 - if (ret) 1156 1156 - goto out; 1157 1157 - rdtgrp->mode = RDT_MODE_PSEUDO_LOCKSETUP; 1158 1158 - } else { 1159 1159 - rdt_last_cmd_puts("Unknown or unsupported mode\n"); 1160 1160 - ret = -EINVAL; 1161 1161 - } 1162 1162 - 1163 1163 - out: 1164 1164 - rdtgroup_kn_unlock(of->kn); 1165 1165 - return ret ?: nbytes; 1166 1166 - } 1167 1167 - 1168 1168 - /** 1169 1169 - * rdtgroup_cbm_to_size - Translate CBM to size in bytes 1170 1170 - * @r: RDT resource to which @d belongs. 1171 1171 - * @d: RDT domain instance. 1172 1172 - * @cbm: bitmask for which the size should be computed. 1173 1173 - * 1174 1174 - * The bitmask provided associated with the RDT domain instance @d will be 1175 1175 - * translated into how many bytes it represents. The size in bytes is 1176 1176 - * computed by first dividing the total cache size by the CBM length to 1177 1177 - * determine how many bytes each bit in the bitmask represents. The result 1178 1178 - * is multiplied with the number of bits set in the bitmask. 1179 1179 - * 1180 1180 - * @cbm is unsigned long, even if only 32 bits are used to make the 1181 1181 - * bitmap functions work correctly. 1182 1182 - */ 1183 1183 - unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, 1184 1184 - struct rdt_ctrl_domain *d, unsigned long cbm) 1185 1185 - { 1186 1186 - unsigned int size = 0; 1187 1187 - struct cacheinfo *ci; 1188 1188 - int num_b; 1189 1189 - 1190 1190 - if (WARN_ON_ONCE(r->ctrl_scope != RESCTRL_L2_CACHE && r->ctrl_scope != RESCTRL_L3_CACHE)) 1191 1191 - return size; 1192 1192 - 1193 1193 - num_b = bitmap_weight(&cbm, r->cache.cbm_len); 1194 1194 - ci = get_cpu_cacheinfo_level(cpumask_any(&d->hdr.cpu_mask), r->ctrl_scope); 1195 1195 - if (ci) 1196 1196 - size = ci->size / r->cache.cbm_len * num_b; 1197 1197 - 1198 1198 - return size; 1199 1199 - } 1200 1200 - 1201 1201 - /* 1202 1202 - * rdtgroup_size_show - Display size in bytes of allocated regions 1203 1203 - * 1204 1204 - * The "size" file mirrors the layout of the "schemata" file, printing the 1205 1205 - * size in bytes of each region instead of the capacity bitmask. 1206 1206 - */ 1207 1207 - static int rdtgroup_size_show(struct kernfs_open_file *of, 1208 1208 - struct seq_file *s, void *v) 1209 1209 - { 1210 1210 - struct resctrl_schema *schema; 1211 1211 - enum resctrl_conf_type type; 1212 1212 - struct rdt_ctrl_domain *d; 1213 1213 - struct rdtgroup *rdtgrp; 1214 1214 - struct rdt_resource *r; 1215 1215 - unsigned int size; 1216 1216 - int ret = 0; 1217 1217 - u32 closid; 1218 1218 - bool sep; 1219 1219 - u32 ctrl; 1220 1220 - 1221 1221 - rdtgrp = rdtgroup_kn_lock_live(of->kn); 1222 1222 - if (!rdtgrp) { 1223 1223 - rdtgroup_kn_unlock(of->kn); 1224 1224 - return -ENOENT; 1225 1225 - } 1226 1226 - 1227 1227 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 1228 1228 - if (!rdtgrp->plr->d) { 1229 1229 - rdt_last_cmd_clear(); 1230 1230 - rdt_last_cmd_puts("Cache domain offline\n"); 1231 1231 - ret = -ENODEV; 1232 1232 - } else { 1233 1233 - seq_printf(s, "%*s:", max_name_width, 1234 1234 - rdtgrp->plr->s->name); 1235 1235 - size = rdtgroup_cbm_to_size(rdtgrp->plr->s->res, 1236 1236 - rdtgrp->plr->d, 1237 1237 - rdtgrp->plr->cbm); 1238 1238 - seq_printf(s, "%d=%u\n", rdtgrp->plr->d->hdr.id, size); 1239 1239 - } 1240 1240 - goto out; 1241 1241 - } 1242 1242 - 1243 1243 - closid = rdtgrp->closid; 1244 1244 - 1245 1245 - list_for_each_entry(schema, &resctrl_schema_all, list) { 1246 1246 - r = schema->res; 1247 1247 - type = schema->conf_type; 1248 1248 - sep = false; 1249 1249 - seq_printf(s, "%*s:", max_name_width, schema->name); 1250 1250 - list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 1251 1251 - if (sep) 1252 1252 - seq_putc(s, ';'); 1253 1253 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1254 1254 - size = 0; 1255 1255 - } else { 1256 1256 - if (is_mba_sc(r)) 1257 1257 - ctrl = d->mbps_val[closid]; 1258 1258 - else 1259 1259 - ctrl = resctrl_arch_get_config(r, d, 1260 1260 - closid, 1261 1261 - type); 1262 1262 - if (r->rid == RDT_RESOURCE_MBA || 1263 1263 - r->rid == RDT_RESOURCE_SMBA) 1264 1264 - size = ctrl; 1265 1265 - else 1266 1266 - size = rdtgroup_cbm_to_size(r, d, ctrl); 1267 1267 - } 1268 1268 - seq_printf(s, "%d=%u", d->hdr.id, size); 1269 1269 - sep = true; 1270 1270 - } 1271 1271 - seq_putc(s, '\n'); 1272 1272 - } 1273 1273 - 1274 1274 - out: 1275 1275 - rdtgroup_kn_unlock(of->kn); 1276 1276 - 1277 1277 - return ret; 385 385 + resctrl_arch_sched_in(current); 1278 386 } 1279 387 1280 388 #define INVALID_CONFIG_INDEX UINT_MAX ··· 102 1642 config_info->mon_config = msrval & MAX_EVT_CONFIG_BITS; 103 1643 } 104 1644 105 105 - static void mondata_config_read(struct resctrl_mon_config_info *mon_info) 106 106 - { 107 107 - smp_call_function_any(&mon_info->d->hdr.cpu_mask, 108 108 - resctrl_arch_mon_event_config_read, mon_info, 1); 109 109 - } 110 110 - 111 111 - static int mbm_config_show(struct seq_file *s, struct rdt_resource *r, u32 evtid) 112 112 - { 113 113 - struct resctrl_mon_config_info mon_info; 114 114 - struct rdt_mon_domain *dom; 115 115 - bool sep = false; 116 116 - 117 117 - cpus_read_lock(); 118 118 - mutex_lock(&rdtgroup_mutex); 119 119 - 120 120 - list_for_each_entry(dom, &r->mon_domains, hdr.list) { 121 121 - if (sep) 122 122 - seq_puts(s, ";"); 123 123 - 124 124 - memset(&mon_info, 0, sizeof(struct resctrl_mon_config_info)); 125 125 - mon_info.r = r; 126 126 - mon_info.d = dom; 127 127 - mon_info.evtid = evtid; 128 128 - mondata_config_read(&mon_info); 129 129 - 130 130 - seq_printf(s, "%d=0x%02x", dom->hdr.id, mon_info.mon_config); 131 131 - sep = true; 132 132 - } 133 133 - seq_puts(s, "\n"); 134 134 - 135 135 - mutex_unlock(&rdtgroup_mutex); 136 136 - cpus_read_unlock(); 137 137 - 138 138 - return 0; 139 139 - } 140 140 - 141 141 - static int mbm_total_bytes_config_show(struct kernfs_open_file *of, 142 142 - struct seq_file *seq, void *v) 143 143 - { 144 144 - struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 145 145 - 146 146 - mbm_config_show(seq, r, QOS_L3_MBM_TOTAL_EVENT_ID); 147 147 - 148 148 - return 0; 149 149 - } 150 150 - 151 151 - static int mbm_local_bytes_config_show(struct kernfs_open_file *of, 152 152 - struct seq_file *seq, void *v) 153 153 - { 154 154 - struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 155 155 - 156 156 - mbm_config_show(seq, r, QOS_L3_MBM_LOCAL_EVENT_ID); 157 157 - 158 158 - return 0; 159 159 - } 160 160 - 161 1645 void resctrl_arch_mon_event_config_write(void *_config_info) 162 1646 { 163 1647 struct resctrl_mon_config_info *config_info = _config_info; ··· 113 1709 return; 114 1710 } 115 1711 wrmsrq(MSR_IA32_EVT_CFG_BASE + index, config_info->mon_config); 116 116 - } 117 117 - 118 118 - static void mbm_config_write_domain(struct rdt_resource *r, 119 119 - struct rdt_mon_domain *d, u32 evtid, u32 val) 120 120 - { 121 121 - struct resctrl_mon_config_info mon_info = {0}; 122 122 - 123 123 - /* 124 124 - * Read the current config value first. If both are the same then 125 125 - * no need to write it again. 126 126 - */ 127 127 - mon_info.r = r; 128 128 - mon_info.d = d; 129 129 - mon_info.evtid = evtid; 130 130 - mondata_config_read(&mon_info); 131 131 - if (mon_info.mon_config == val) 132 132 - return; 133 133 - 134 134 - mon_info.mon_config = val; 135 135 - 136 136 - /* 137 137 - * Update MSR_IA32_EVT_CFG_BASE MSR on one of the CPUs in the 138 138 - * domain. The MSRs offset from MSR MSR_IA32_EVT_CFG_BASE 139 139 - * are scoped at the domain level. Writing any of these MSRs 140 140 - * on one CPU is observed by all the CPUs in the domain. 141 141 - */ 142 142 - smp_call_function_any(&d->hdr.cpu_mask, resctrl_arch_mon_event_config_write, 143 143 - &mon_info, 1); 144 144 - 145 145 - /* 146 146 - * When an Event Configuration is changed, the bandwidth counters 147 147 - * for all RMIDs and Events will be cleared by the hardware. The 148 148 - * hardware also sets MSR_IA32_QM_CTR.Unavailable (bit 62) for 149 149 - * every RMID on the next read to any event for every RMID. 150 150 - * Subsequent reads will have MSR_IA32_QM_CTR.Unavailable (bit 62) 151 151 - * cleared while it is tracked by the hardware. Clear the 152 152 - * mbm_local and mbm_total counts for all the RMIDs. 153 153 - */ 154 154 - resctrl_arch_reset_rmid_all(r, d); 155 155 - } 156 156 - 157 157 - static int mon_config_write(struct rdt_resource *r, char *tok, u32 evtid) 158 158 - { 159 159 - char *dom_str = NULL, *id_str; 160 160 - unsigned long dom_id, val; 161 161 - struct rdt_mon_domain *d; 162 162 - 163 163 - /* Walking r->domains, ensure it can't race with cpuhp */ 164 164 - lockdep_assert_cpus_held(); 165 165 - 166 166 - next: 167 167 - if (!tok || tok[0] == '\0') 168 168 - return 0; 169 169 - 170 170 - /* Start processing the strings for each domain */ 171 171 - dom_str = strim(strsep(&tok, ";")); 172 172 - id_str = strsep(&dom_str, "="); 173 173 - 174 174 - if (!id_str || kstrtoul(id_str, 10, &dom_id)) { 175 175 - rdt_last_cmd_puts("Missing '=' or non-numeric domain id\n"); 176 176 - return -EINVAL; 177 177 - } 178 178 - 179 179 - if (!dom_str || kstrtoul(dom_str, 16, &val)) { 180 180 - rdt_last_cmd_puts("Non-numeric event configuration value\n"); 181 181 - return -EINVAL; 182 182 - } 183 183 - 184 184 - /* Value from user cannot be more than the supported set of events */ 185 185 - if ((val & r->mbm_cfg_mask) != val) { 186 186 - rdt_last_cmd_printf("Invalid event configuration: max valid mask is 0x%02x\n", 187 187 - r->mbm_cfg_mask); 188 188 - return -EINVAL; 189 189 - } 190 190 - 191 191 - list_for_each_entry(d, &r->mon_domains, hdr.list) { 192 192 - if (d->hdr.id == dom_id) { 193 193 - mbm_config_write_domain(r, d, evtid, val); 194 194 - goto next; 195 195 - } 196 196 - } 197 197 - 198 198 - return -EINVAL; 199 199 - } 200 200 - 201 201 - static ssize_t mbm_total_bytes_config_write(struct kernfs_open_file *of, 202 202 - char *buf, size_t nbytes, 203 203 - loff_t off) 204 204 - { 205 205 - struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 206 206 - int ret; 207 207 - 208 208 - /* Valid input requires a trailing newline */ 209 209 - if (nbytes == 0 || buf[nbytes - 1] != '\n') 210 210 - return -EINVAL; 211 211 - 212 212 - cpus_read_lock(); 213 213 - mutex_lock(&rdtgroup_mutex); 214 214 - 215 215 - rdt_last_cmd_clear(); 216 216 - 217 217 - buf[nbytes - 1] = '\0'; 218 218 - 219 219 - ret = mon_config_write(r, buf, QOS_L3_MBM_TOTAL_EVENT_ID); 220 220 - 221 221 - mutex_unlock(&rdtgroup_mutex); 222 222 - cpus_read_unlock(); 223 223 - 224 224 - return ret ?: nbytes; 225 225 - } 226 226 - 227 227 - static ssize_t mbm_local_bytes_config_write(struct kernfs_open_file *of, 228 228 - char *buf, size_t nbytes, 229 229 - loff_t off) 230 230 - { 231 231 - struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 232 232 - int ret; 233 233 - 234 234 - /* Valid input requires a trailing newline */ 235 235 - if (nbytes == 0 || buf[nbytes - 1] != '\n') 236 236 - return -EINVAL; 237 237 - 238 238 - cpus_read_lock(); 239 239 - mutex_lock(&rdtgroup_mutex); 240 240 - 241 241 - rdt_last_cmd_clear(); 242 242 - 243 243 - buf[nbytes - 1] = '\0'; 244 244 - 245 245 - ret = mon_config_write(r, buf, QOS_L3_MBM_LOCAL_EVENT_ID); 246 246 - 247 247 - mutex_unlock(&rdtgroup_mutex); 248 248 - cpus_read_unlock(); 249 249 - 250 250 - return ret ?: nbytes; 251 251 - } 252 252 - 253 253 - /* rdtgroup information files for one cache resource. */ 254 254 - static struct rftype res_common_files[] = { 255 255 - { 256 256 - .name = "last_cmd_status", 257 257 - .mode = 0444, 258 258 - .kf_ops = &rdtgroup_kf_single_ops, 259 259 - .seq_show = rdt_last_cmd_status_show, 260 260 - .fflags = RFTYPE_TOP_INFO, 261 261 - }, 262 262 - { 263 263 - .name = "num_closids", 264 264 - .mode = 0444, 265 265 - .kf_ops = &rdtgroup_kf_single_ops, 266 266 - .seq_show = rdt_num_closids_show, 267 267 - .fflags = RFTYPE_CTRL_INFO, 268 268 - }, 269 269 - { 270 270 - .name = "mon_features", 271 271 - .mode = 0444, 272 272 - .kf_ops = &rdtgroup_kf_single_ops, 273 273 - .seq_show = rdt_mon_features_show, 274 274 - .fflags = RFTYPE_MON_INFO, 275 275 - }, 276 276 - { 277 277 - .name = "num_rmids", 278 278 - .mode = 0444, 279 279 - .kf_ops = &rdtgroup_kf_single_ops, 280 280 - .seq_show = rdt_num_rmids_show, 281 281 - .fflags = RFTYPE_MON_INFO, 282 282 - }, 283 283 - { 284 284 - .name = "cbm_mask", 285 285 - .mode = 0444, 286 286 - .kf_ops = &rdtgroup_kf_single_ops, 287 287 - .seq_show = rdt_default_ctrl_show, 288 288 - .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 289 289 - }, 290 290 - { 291 291 - .name = "min_cbm_bits", 292 292 - .mode = 0444, 293 293 - .kf_ops = &rdtgroup_kf_single_ops, 294 294 - .seq_show = rdt_min_cbm_bits_show, 295 295 - .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 296 296 - }, 297 297 - { 298 298 - .name = "shareable_bits", 299 299 - .mode = 0444, 300 300 - .kf_ops = &rdtgroup_kf_single_ops, 301 301 - .seq_show = rdt_shareable_bits_show, 302 302 - .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 303 303 - }, 304 304 - { 305 305 - .name = "bit_usage", 306 306 - .mode = 0444, 307 307 - .kf_ops = &rdtgroup_kf_single_ops, 308 308 - .seq_show = rdt_bit_usage_show, 309 309 - .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 310 310 - }, 311 311 - { 312 312 - .name = "min_bandwidth", 313 313 - .mode = 0444, 314 314 - .kf_ops = &rdtgroup_kf_single_ops, 315 315 - .seq_show = rdt_min_bw_show, 316 316 - .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_MB, 317 317 - }, 318 318 - { 319 319 - .name = "bandwidth_gran", 320 320 - .mode = 0444, 321 321 - .kf_ops = &rdtgroup_kf_single_ops, 322 322 - .seq_show = rdt_bw_gran_show, 323 323 - .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_MB, 324 324 - }, 325 325 - { 326 326 - .name = "delay_linear", 327 327 - .mode = 0444, 328 328 - .kf_ops = &rdtgroup_kf_single_ops, 329 329 - .seq_show = rdt_delay_linear_show, 330 330 - .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_MB, 331 331 - }, 332 332 - /* 333 333 - * Platform specific which (if any) capabilities are provided by 334 334 - * thread_throttle_mode. Defer "fflags" initialization to platform 335 335 - * discovery. 336 336 - */ 337 337 - { 338 338 - .name = "thread_throttle_mode", 339 339 - .mode = 0444, 340 340 - .kf_ops = &rdtgroup_kf_single_ops, 341 341 - .seq_show = rdt_thread_throttle_mode_show, 342 342 - }, 343 343 - { 344 344 - .name = "max_threshold_occupancy", 345 345 - .mode = 0644, 346 346 - .kf_ops = &rdtgroup_kf_single_ops, 347 347 - .write = max_threshold_occ_write, 348 348 - .seq_show = max_threshold_occ_show, 349 349 - .fflags = RFTYPE_MON_INFO | RFTYPE_RES_CACHE, 350 350 - }, 351 351 - { 352 352 - .name = "mbm_total_bytes_config", 353 353 - .mode = 0644, 354 354 - .kf_ops = &rdtgroup_kf_single_ops, 355 355 - .seq_show = mbm_total_bytes_config_show, 356 356 - .write = mbm_total_bytes_config_write, 357 357 - }, 358 358 - { 359 359 - .name = "mbm_local_bytes_config", 360 360 - .mode = 0644, 361 361 - .kf_ops = &rdtgroup_kf_single_ops, 362 362 - .seq_show = mbm_local_bytes_config_show, 363 363 - .write = mbm_local_bytes_config_write, 364 364 - }, 365 365 - { 366 366 - .name = "cpus", 367 367 - .mode = 0644, 368 368 - .kf_ops = &rdtgroup_kf_single_ops, 369 369 - .write = rdtgroup_cpus_write, 370 370 - .seq_show = rdtgroup_cpus_show, 371 371 - .fflags = RFTYPE_BASE, 372 372 - }, 373 373 - { 374 374 - .name = "cpus_list", 375 375 - .mode = 0644, 376 376 - .kf_ops = &rdtgroup_kf_single_ops, 377 377 - .write = rdtgroup_cpus_write, 378 378 - .seq_show = rdtgroup_cpus_show, 379 379 - .flags = RFTYPE_FLAGS_CPUS_LIST, 380 380 - .fflags = RFTYPE_BASE, 381 381 - }, 382 382 - { 383 383 - .name = "tasks", 384 384 - .mode = 0644, 385 385 - .kf_ops = &rdtgroup_kf_single_ops, 386 386 - .write = rdtgroup_tasks_write, 387 387 - .seq_show = rdtgroup_tasks_show, 388 388 - .fflags = RFTYPE_BASE, 389 389 - }, 390 390 - { 391 391 - .name = "mon_hw_id", 392 392 - .mode = 0444, 393 393 - .kf_ops = &rdtgroup_kf_single_ops, 394 394 - .seq_show = rdtgroup_rmid_show, 395 395 - .fflags = RFTYPE_MON_BASE | RFTYPE_DEBUG, 396 396 - }, 397 397 - { 398 398 - .name = "schemata", 399 399 - .mode = 0644, 400 400 - .kf_ops = &rdtgroup_kf_single_ops, 401 401 - .write = rdtgroup_schemata_write, 402 402 - .seq_show = rdtgroup_schemata_show, 403 403 - .fflags = RFTYPE_CTRL_BASE, 404 404 - }, 405 405 - { 406 406 - .name = "mba_MBps_event", 407 407 - .mode = 0644, 408 408 - .kf_ops = &rdtgroup_kf_single_ops, 409 409 - .write = rdtgroup_mba_mbps_event_write, 410 410 - .seq_show = rdtgroup_mba_mbps_event_show, 411 411 - }, 412 412 - { 413 413 - .name = "mode", 414 414 - .mode = 0644, 415 415 - .kf_ops = &rdtgroup_kf_single_ops, 416 416 - .write = rdtgroup_mode_write, 417 417 - .seq_show = rdtgroup_mode_show, 418 418 - .fflags = RFTYPE_CTRL_BASE, 419 419 - }, 420 420 - { 421 421 - .name = "size", 422 422 - .mode = 0444, 423 423 - .kf_ops = &rdtgroup_kf_single_ops, 424 424 - .seq_show = rdtgroup_size_show, 425 425 - .fflags = RFTYPE_CTRL_BASE, 426 426 - }, 427 427 - { 428 428 - .name = "sparse_masks", 429 429 - .mode = 0444, 430 430 - .kf_ops = &rdtgroup_kf_single_ops, 431 431 - .seq_show = rdt_has_sparse_bitmasks_show, 432 432 - .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 433 433 - }, 434 434 - { 435 435 - .name = "ctrl_hw_id", 436 436 - .mode = 0444, 437 437 - .kf_ops = &rdtgroup_kf_single_ops, 438 438 - .seq_show = rdtgroup_closid_show, 439 439 - .fflags = RFTYPE_CTRL_BASE | RFTYPE_DEBUG, 440 440 - }, 441 441 - 442 442 - }; 443 443 - 444 444 - static int rdtgroup_add_files(struct kernfs_node *kn, unsigned long fflags) 445 445 - { 446 446 - struct rftype *rfts, *rft; 447 447 - int ret, len; 448 448 - 449 449 - rfts = res_common_files; 450 450 - len = ARRAY_SIZE(res_common_files); 451 451 - 452 452 - lockdep_assert_held(&rdtgroup_mutex); 453 453 - 454 454 - if (resctrl_debug) 455 455 - fflags |= RFTYPE_DEBUG; 456 456 - 457 457 - for (rft = rfts; rft < rfts + len; rft++) { 458 458 - if (rft->fflags && ((fflags & rft->fflags) == rft->fflags)) { 459 459 - ret = rdtgroup_add_file(kn, rft); 460 460 - if (ret) 461 461 - goto error; 462 462 - } 463 463 - } 464 464 - 465 465 - return 0; 466 466 - error: 467 467 - pr_warn("Failed to add %s, err=%d\n", rft->name, ret); 468 468 - while (--rft >= rfts) { 469 469 - if ((fflags & rft->fflags) == rft->fflags) 470 470 - kernfs_remove_by_name(kn, rft->name); 471 471 - } 472 472 - return ret; 473 473 - } 474 474 - 475 475 - static struct rftype *rdtgroup_get_rftype_by_name(const char *name) 476 476 - { 477 477 - struct rftype *rfts, *rft; 478 478 - int len; 479 479 - 480 480 - rfts = res_common_files; 481 481 - len = ARRAY_SIZE(res_common_files); 482 482 - 483 483 - for (rft = rfts; rft < rfts + len; rft++) { 484 484 - if (!strcmp(rft->name, name)) 485 485 - return rft; 486 486 - } 487 487 - 488 488 - return NULL; 489 489 - } 490 490 - 491 491 - static void thread_throttle_mode_init(void) 492 492 - { 493 493 - enum membw_throttle_mode throttle_mode = THREAD_THROTTLE_UNDEFINED; 494 494 - struct rdt_resource *r_mba, *r_smba; 495 495 - 496 496 - r_mba = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 497 497 - if (r_mba->alloc_capable && 498 498 - r_mba->membw.throttle_mode != THREAD_THROTTLE_UNDEFINED) 499 499 - throttle_mode = r_mba->membw.throttle_mode; 500 500 - 501 501 - r_smba = resctrl_arch_get_resource(RDT_RESOURCE_SMBA); 502 502 - if (r_smba->alloc_capable && 503 503 - r_smba->membw.throttle_mode != THREAD_THROTTLE_UNDEFINED) 504 504 - throttle_mode = r_smba->membw.throttle_mode; 505 505 - 506 506 - if (throttle_mode == THREAD_THROTTLE_UNDEFINED) 507 507 - return; 508 508 - 509 509 - resctrl_file_fflags_init("thread_throttle_mode", 510 510 - RFTYPE_CTRL_INFO | RFTYPE_RES_MB); 511 511 - } 512 512 - 513 513 - void resctrl_file_fflags_init(const char *config, unsigned long fflags) 514 514 - { 515 515 - struct rftype *rft; 516 516 - 517 517 - rft = rdtgroup_get_rftype_by_name(config); 518 518 - if (rft) 519 519 - rft->fflags = fflags; 520 520 - } 521 521 - 522 522 - /** 523 523 - * rdtgroup_kn_mode_restrict - Restrict user access to named resctrl file 524 524 - * @r: The resource group with which the file is associated. 525 525 - * @name: Name of the file 526 526 - * 527 527 - * The permissions of named resctrl file, directory, or link are modified 528 528 - * to not allow read, write, or execute by any user. 529 529 - * 530 530 - * WARNING: This function is intended to communicate to the user that the 531 531 - * resctrl file has been locked down - that it is not relevant to the 532 532 - * particular state the system finds itself in. It should not be relied 533 533 - * on to protect from user access because after the file's permissions 534 534 - * are restricted the user can still change the permissions using chmod 535 535 - * from the command line. 536 536 - * 537 537 - * Return: 0 on success, <0 on failure. 538 538 - */ 539 539 - int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name) 540 540 - { 541 541 - struct iattr iattr = {.ia_valid = ATTR_MODE,}; 542 542 - struct kernfs_node *kn; 543 543 - int ret = 0; 544 544 - 545 545 - kn = kernfs_find_and_get_ns(r->kn, name, NULL); 546 546 - if (!kn) 547 547 - return -ENOENT; 548 548 - 549 549 - switch (kernfs_type(kn)) { 550 550 - case KERNFS_DIR: 551 551 - iattr.ia_mode = S_IFDIR; 552 552 - break; 553 553 - case KERNFS_FILE: 554 554 - iattr.ia_mode = S_IFREG; 555 555 - break; 556 556 - case KERNFS_LINK: 557 557 - iattr.ia_mode = S_IFLNK; 558 558 - break; 559 559 - } 560 560 - 561 561 - ret = kernfs_setattr(kn, &iattr); 562 562 - kernfs_put(kn); 563 563 - return ret; 564 564 - } 565 565 - 566 566 - /** 567 567 - * rdtgroup_kn_mode_restore - Restore user access to named resctrl file 568 568 - * @r: The resource group with which the file is associated. 569 569 - * @name: Name of the file 570 570 - * @mask: Mask of permissions that should be restored 571 571 - * 572 572 - * Restore the permissions of the named file. If @name is a directory the 573 573 - * permissions of its parent will be used. 574 574 - * 575 575 - * Return: 0 on success, <0 on failure. 576 576 - */ 577 577 - int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, 578 578 - umode_t mask) 579 579 - { 580 580 - struct iattr iattr = {.ia_valid = ATTR_MODE,}; 581 581 - struct kernfs_node *kn, *parent; 582 582 - struct rftype *rfts, *rft; 583 583 - int ret, len; 584 584 - 585 585 - rfts = res_common_files; 586 586 - len = ARRAY_SIZE(res_common_files); 587 587 - 588 588 - for (rft = rfts; rft < rfts + len; rft++) { 589 589 - if (!strcmp(rft->name, name)) 590 590 - iattr.ia_mode = rft->mode & mask; 591 591 - } 592 592 - 593 593 - kn = kernfs_find_and_get_ns(r->kn, name, NULL); 594 594 - if (!kn) 595 595 - return -ENOENT; 596 596 - 597 597 - switch (kernfs_type(kn)) { 598 598 - case KERNFS_DIR: 599 599 - parent = kernfs_get_parent(kn); 600 600 - if (parent) { 601 601 - iattr.ia_mode |= parent->mode; 602 602 - kernfs_put(parent); 603 603 - } 604 604 - iattr.ia_mode |= S_IFDIR; 605 605 - break; 606 606 - case KERNFS_FILE: 607 607 - iattr.ia_mode |= S_IFREG; 608 608 - break; 609 609 - case KERNFS_LINK: 610 610 - iattr.ia_mode |= S_IFLNK; 611 611 - break; 612 612 - } 613 613 - 614 614 - ret = kernfs_setattr(kn, &iattr); 615 615 - kernfs_put(kn); 616 616 - return ret; 617 617 - } 618 618 - 619 619 - static int rdtgroup_mkdir_info_resdir(void *priv, char *name, 620 620 - unsigned long fflags) 621 621 - { 622 622 - struct kernfs_node *kn_subdir; 623 623 - int ret; 624 624 - 625 625 - kn_subdir = kernfs_create_dir(kn_info, name, 626 626 - kn_info->mode, priv); 627 627 - if (IS_ERR(kn_subdir)) 628 628 - return PTR_ERR(kn_subdir); 629 629 - 630 630 - ret = rdtgroup_kn_set_ugid(kn_subdir); 631 631 - if (ret) 632 632 - return ret; 633 633 - 634 634 - ret = rdtgroup_add_files(kn_subdir, fflags); 635 635 - if (!ret) 636 636 - kernfs_activate(kn_subdir); 637 637 - 638 638 - return ret; 639 639 - } 640 640 - 641 641 - static unsigned long fflags_from_resource(struct rdt_resource *r) 642 642 - { 643 643 - switch (r->rid) { 644 644 - case RDT_RESOURCE_L3: 645 645 - case RDT_RESOURCE_L2: 646 646 - return RFTYPE_RES_CACHE; 647 647 - case RDT_RESOURCE_MBA: 648 648 - case RDT_RESOURCE_SMBA: 649 649 - return RFTYPE_RES_MB; 650 650 - } 651 651 - 652 652 - return WARN_ON_ONCE(1); 653 653 - } 654 654 - 655 655 - static int rdtgroup_create_info_dir(struct kernfs_node *parent_kn) 656 656 - { 657 657 - struct resctrl_schema *s; 658 658 - struct rdt_resource *r; 659 659 - unsigned long fflags; 660 660 - char name[32]; 661 661 - int ret; 662 662 - 663 663 - /* create the directory */ 664 664 - kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL); 665 665 - if (IS_ERR(kn_info)) 666 666 - return PTR_ERR(kn_info); 667 667 - 668 668 - ret = rdtgroup_add_files(kn_info, RFTYPE_TOP_INFO); 669 669 - if (ret) 670 670 - goto out_destroy; 671 671 - 672 672 - /* loop over enabled controls, these are all alloc_capable */ 673 673 - list_for_each_entry(s, &resctrl_schema_all, list) { 674 674 - r = s->res; 675 675 - fflags = fflags_from_resource(r) | RFTYPE_CTRL_INFO; 676 676 - ret = rdtgroup_mkdir_info_resdir(s, s->name, fflags); 677 677 - if (ret) 678 678 - goto out_destroy; 679 679 - } 680 680 - 681 681 - for_each_mon_capable_rdt_resource(r) { 682 682 - fflags = fflags_from_resource(r) | RFTYPE_MON_INFO; 683 683 - sprintf(name, "%s_MON", r->name); 684 684 - ret = rdtgroup_mkdir_info_resdir(r, name, fflags); 685 685 - if (ret) 686 686 - goto out_destroy; 687 687 - } 688 688 - 689 689 - ret = rdtgroup_kn_set_ugid(kn_info); 690 690 - if (ret) 691 691 - goto out_destroy; 692 692 - 693 693 - kernfs_activate(kn_info); 694 694 - 695 695 - return 0; 696 696 - 697 697 - out_destroy: 698 698 - kernfs_remove(kn_info); 699 699 - return ret; 700 700 - } 701 701 - 702 702 - static int 703 703 - mongroup_create_dir(struct kernfs_node *parent_kn, struct rdtgroup *prgrp, 704 704 - char *name, struct kernfs_node **dest_kn) 705 705 - { 706 706 - struct kernfs_node *kn; 707 707 - int ret; 708 708 - 709 709 - /* create the directory */ 710 710 - kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 711 711 - if (IS_ERR(kn)) 712 712 - return PTR_ERR(kn); 713 713 - 714 714 - if (dest_kn) 715 715 - *dest_kn = kn; 716 716 - 717 717 - ret = rdtgroup_kn_set_ugid(kn); 718 718 - if (ret) 719 719 - goto out_destroy; 720 720 - 721 721 - kernfs_activate(kn); 722 722 - 723 723 - return 0; 724 724 - 725 725 - out_destroy: 726 726 - kernfs_remove(kn); 727 727 - return ret; 728 1712 } 729 1713 730 1714 static void l3_qos_cfg_update(void *arg) ··· 127 2335 bool *enable = arg; 128 2336 129 2337 wrmsrq(MSR_IA32_L2_QOS_CFG, *enable ? L2_QOS_CDP_ENABLE : 0ULL); 130 130 - } 131 131 - 132 132 - static inline bool is_mba_linear(void) 133 133 - { 134 134 - return resctrl_arch_get_resource(RDT_RESOURCE_MBA)->membw.delay_linear; 135 2338 } 136 2339 137 2340 static int set_cache_qos_cfg(int level, bool enable) ··· 184 2397 l3_qos_cfg_update(&hw_res->cdp_enabled); 185 2398 } 186 2399 187 187 - static int mba_sc_domain_allocate(struct rdt_resource *r, struct rdt_ctrl_domain *d) 188 188 - { 189 189 - u32 num_closid = resctrl_arch_get_num_closid(r); 190 190 - int cpu = cpumask_any(&d->hdr.cpu_mask); 191 191 - int i; 192 192 - 193 193 - d->mbps_val = kcalloc_node(num_closid, sizeof(*d->mbps_val), 194 194 - GFP_KERNEL, cpu_to_node(cpu)); 195 195 - if (!d->mbps_val) 196 196 - return -ENOMEM; 197 197 - 198 198 - for (i = 0; i < num_closid; i++) 199 199 - d->mbps_val[i] = MBA_MAX_MBPS; 200 200 - 201 201 - return 0; 202 202 - } 203 203 - 204 204 - static void mba_sc_domain_destroy(struct rdt_resource *r, 205 205 - struct rdt_ctrl_domain *d) 206 206 - { 207 207 - kfree(d->mbps_val); 208 208 - d->mbps_val = NULL; 209 209 - } 210 210 - 211 211 - /* 212 212 - * MBA software controller is supported only if 213 213 - * MBM is supported and MBA is in linear scale, 214 214 - * and the MBM monitor scope is the same as MBA 215 215 - * control scope. 216 216 - */ 217 217 - static bool supports_mba_mbps(void) 218 218 - { 219 219 - struct rdt_resource *rmbm = resctrl_arch_get_resource(RDT_RESOURCE_L3); 220 220 - struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 221 221 - 222 222 - return (resctrl_is_mbm_enabled() && 223 223 - r->alloc_capable && is_mba_linear() && 224 224 - r->ctrl_scope == rmbm->mon_scope); 225 225 - } 226 226 - 227 227 - /* 228 228 - * Enable or disable the MBA software controller 229 229 - * which helps user specify bandwidth in MBps. 230 230 - */ 231 231 - static int set_mba_sc(bool mba_sc) 232 232 - { 233 233 - struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 234 234 - u32 num_closid = resctrl_arch_get_num_closid(r); 235 235 - struct rdt_ctrl_domain *d; 236 236 - unsigned long fflags; 237 237 - int i; 238 238 - 239 239 - if (!supports_mba_mbps() || mba_sc == is_mba_sc(r)) 240 240 - return -EINVAL; 241 241 - 242 242 - r->membw.mba_sc = mba_sc; 243 243 - 244 244 - rdtgroup_default.mba_mbps_event = mba_mbps_default_event; 245 245 - 246 246 - list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 247 247 - for (i = 0; i < num_closid; i++) 248 248 - d->mbps_val[i] = MBA_MAX_MBPS; 249 249 - } 250 250 - 251 251 - fflags = mba_sc ? RFTYPE_CTRL_BASE | RFTYPE_MON_BASE : 0; 252 252 - resctrl_file_fflags_init("mba_MBps_event", fflags); 253 253 - 254 254 - return 0; 255 255 - } 256 256 - 257 2400 static int cdp_enable(int level) 258 2401 { 259 2402 struct rdt_resource *r_l = &rdt_resources_all[level].r_resctrl; ··· 224 2507 return 0; 225 2508 } 226 2509 227 227 - /* 228 228 - * We don't allow rdtgroup directories to be created anywhere 229 229 - * except the root directory. Thus when looking for the rdtgroup 230 230 - * structure for a kernfs node we are either looking at a directory, 231 231 - * in which case the rdtgroup structure is pointed at by the "priv" 232 232 - * field, otherwise we have a file, and need only look to the parent 233 233 - * to find the rdtgroup. 234 234 - */ 235 235 - static struct rdtgroup *kernfs_to_rdtgroup(struct kernfs_node *kn) 2510 2510 + bool resctrl_arch_get_cdp_enabled(enum resctrl_res_level l) 236 2511 { 237 237 - if (kernfs_type(kn) == KERNFS_DIR) { 238 238 - /* 239 239 - * All the resource directories use "kn->priv" 240 240 - * to point to the "struct rdtgroup" for the 241 241 - * resource. "info" and its subdirectories don't 242 242 - * have rdtgroup structures, so return NULL here. 243 243 - */ 244 244 - if (kn == kn_info || 245 245 - rcu_access_pointer(kn->__parent) == kn_info) 246 246 - return NULL; 247 247 - else 248 248 - return kn->priv; 249 249 - } else { 250 250 - return rdt_kn_parent_priv(kn); 251 251 - } 252 252 - } 253 253 - 254 254 - static void rdtgroup_kn_get(struct rdtgroup *rdtgrp, struct kernfs_node *kn) 255 255 - { 256 256 - atomic_inc(&rdtgrp->waitcount); 257 257 - kernfs_break_active_protection(kn); 258 258 - } 259 259 - 260 260 - static void rdtgroup_kn_put(struct rdtgroup *rdtgrp, struct kernfs_node *kn) 261 261 - { 262 262 - if (atomic_dec_and_test(&rdtgrp->waitcount) && 263 263 - (rdtgrp->flags & RDT_DELETED)) { 264 264 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 265 265 - rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 266 266 - rdtgroup_pseudo_lock_remove(rdtgrp); 267 267 - kernfs_unbreak_active_protection(kn); 268 268 - rdtgroup_remove(rdtgrp); 269 269 - } else { 270 270 - kernfs_unbreak_active_protection(kn); 271 271 - } 272 272 - } 273 273 - 274 274 - struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn) 275 275 - { 276 276 - struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 277 277 - 278 278 - if (!rdtgrp) 279 279 - return NULL; 280 280 - 281 281 - rdtgroup_kn_get(rdtgrp, kn); 282 282 - 283 283 - cpus_read_lock(); 284 284 - mutex_lock(&rdtgroup_mutex); 285 285 - 286 286 - /* Was this group deleted while we waited? */ 287 287 - if (rdtgrp->flags & RDT_DELETED) 288 288 - return NULL; 289 289 - 290 290 - return rdtgrp; 291 291 - } 292 292 - 293 293 - void rdtgroup_kn_unlock(struct kernfs_node *kn) 294 294 - { 295 295 - struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 296 296 - 297 297 - if (!rdtgrp) 298 298 - return; 299 299 - 300 300 - mutex_unlock(&rdtgroup_mutex); 301 301 - cpus_read_unlock(); 302 302 - 303 303 - rdtgroup_kn_put(rdtgrp, kn); 304 304 - } 305 305 - 306 306 - static int mkdir_mondata_all(struct kernfs_node *parent_kn, 307 307 - struct rdtgroup *prgrp, 308 308 - struct kernfs_node **mon_data_kn); 309 309 - 310 310 - static void rdt_disable_ctx(void) 311 311 - { 312 312 - resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, false); 313 313 - resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, false); 314 314 - set_mba_sc(false); 315 315 - 316 316 - resctrl_debug = false; 317 317 - } 318 318 - 319 319 - static int rdt_enable_ctx(struct rdt_fs_context *ctx) 320 320 - { 321 321 - int ret = 0; 322 322 - 323 323 - if (ctx->enable_cdpl2) { 324 324 - ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, true); 325 325 - if (ret) 326 326 - goto out_done; 327 327 - } 328 328 - 329 329 - if (ctx->enable_cdpl3) { 330 330 - ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, true); 331 331 - if (ret) 332 332 - goto out_cdpl2; 333 333 - } 334 334 - 335 335 - if (ctx->enable_mba_mbps) { 336 336 - ret = set_mba_sc(true); 337 337 - if (ret) 338 338 - goto out_cdpl3; 339 339 - } 340 340 - 341 341 - if (ctx->enable_debug) 342 342 - resctrl_debug = true; 343 343 - 344 344 - return 0; 345 345 - 346 346 - out_cdpl3: 347 347 - resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, false); 348 348 - out_cdpl2: 349 349 - resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, false); 350 350 - out_done: 351 351 - return ret; 352 352 - } 353 353 - 354 354 - static int schemata_list_add(struct rdt_resource *r, enum resctrl_conf_type type) 355 355 - { 356 356 - struct resctrl_schema *s; 357 357 - const char *suffix = ""; 358 358 - int ret, cl; 359 359 - 360 360 - s = kzalloc(sizeof(*s), GFP_KERNEL); 361 361 - if (!s) 362 362 - return -ENOMEM; 363 363 - 364 364 - s->res = r; 365 365 - s->num_closid = resctrl_arch_get_num_closid(r); 366 366 - if (resctrl_arch_get_cdp_enabled(r->rid)) 367 367 - s->num_closid /= 2; 368 368 - 369 369 - s->conf_type = type; 370 370 - switch (type) { 371 371 - case CDP_CODE: 372 372 - suffix = "CODE"; 373 373 - break; 374 374 - case CDP_DATA: 375 375 - suffix = "DATA"; 376 376 - break; 377 377 - case CDP_NONE: 378 378 - suffix = ""; 379 379 - break; 380 380 - } 381 381 - 382 382 - ret = snprintf(s->name, sizeof(s->name), "%s%s", r->name, suffix); 383 383 - if (ret >= sizeof(s->name)) { 384 384 - kfree(s); 385 385 - return -EINVAL; 386 386 - } 387 387 - 388 388 - cl = strlen(s->name); 389 389 - 390 390 - /* 391 391 - * If CDP is supported by this resource, but not enabled, 392 392 - * include the suffix. This ensures the tabular format of the 393 393 - * schemata file does not change between mounts of the filesystem. 394 394 - */ 395 395 - if (r->cdp_capable && !resctrl_arch_get_cdp_enabled(r->rid)) 396 396 - cl += 4; 397 397 - 398 398 - if (cl > max_name_width) 399 399 - max_name_width = cl; 400 400 - 401 401 - switch (r->schema_fmt) { 402 402 - case RESCTRL_SCHEMA_BITMAP: 403 403 - s->fmt_str = "%d=%x"; 404 404 - break; 405 405 - case RESCTRL_SCHEMA_RANGE: 406 406 - s->fmt_str = "%d=%u"; 407 407 - break; 408 408 - } 409 409 - 410 410 - if (WARN_ON_ONCE(!s->fmt_str)) { 411 411 - kfree(s); 412 412 - return -EINVAL; 413 413 - } 414 414 - 415 415 - INIT_LIST_HEAD(&s->list); 416 416 - list_add(&s->list, &resctrl_schema_all); 417 417 - 418 418 - return 0; 419 419 - } 420 420 - 421 421 - static int schemata_list_create(void) 422 422 - { 423 423 - struct rdt_resource *r; 424 424 - int ret = 0; 425 425 - 426 426 - for_each_alloc_capable_rdt_resource(r) { 427 427 - if (resctrl_arch_get_cdp_enabled(r->rid)) { 428 428 - ret = schemata_list_add(r, CDP_CODE); 429 429 - if (ret) 430 430 - break; 431 431 - 432 432 - ret = schemata_list_add(r, CDP_DATA); 433 433 - } else { 434 434 - ret = schemata_list_add(r, CDP_NONE); 435 435 - } 436 436 - 437 437 - if (ret) 438 438 - break; 439 439 - } 440 440 - 441 441 - return ret; 442 442 - } 443 443 - 444 444 - static void schemata_list_destroy(void) 445 445 - { 446 446 - struct resctrl_schema *s, *tmp; 447 447 - 448 448 - list_for_each_entry_safe(s, tmp, &resctrl_schema_all, list) { 449 449 - list_del(&s->list); 450 450 - kfree(s); 451 451 - } 452 452 - } 453 453 - 454 454 - static int rdt_get_tree(struct fs_context *fc) 455 455 - { 456 456 - struct rdt_fs_context *ctx = rdt_fc2context(fc); 457 457 - unsigned long flags = RFTYPE_CTRL_BASE; 458 458 - struct rdt_mon_domain *dom; 459 459 - struct rdt_resource *r; 460 460 - int ret; 461 461 - 462 462 - cpus_read_lock(); 463 463 - mutex_lock(&rdtgroup_mutex); 464 464 - /* 465 465 - * resctrl file system can only be mounted once. 466 466 - */ 467 467 - if (resctrl_mounted) { 468 468 - ret = -EBUSY; 469 469 - goto out; 470 470 - } 471 471 - 472 472 - ret = rdtgroup_setup_root(ctx); 473 473 - if (ret) 474 474 - goto out; 475 475 - 476 476 - ret = rdt_enable_ctx(ctx); 477 477 - if (ret) 478 478 - goto out_root; 479 479 - 480 480 - ret = schemata_list_create(); 481 481 - if (ret) { 482 482 - schemata_list_destroy(); 483 483 - goto out_ctx; 484 484 - } 485 485 - 486 486 - closid_init(); 487 487 - 488 488 - if (resctrl_arch_mon_capable()) 489 489 - flags |= RFTYPE_MON; 490 490 - 491 491 - ret = rdtgroup_add_files(rdtgroup_default.kn, flags); 492 492 - if (ret) 493 493 - goto out_schemata_free; 494 494 - 495 495 - kernfs_activate(rdtgroup_default.kn); 496 496 - 497 497 - ret = rdtgroup_create_info_dir(rdtgroup_default.kn); 498 498 - if (ret < 0) 499 499 - goto out_schemata_free; 500 500 - 501 501 - if (resctrl_arch_mon_capable()) { 502 502 - ret = mongroup_create_dir(rdtgroup_default.kn, 503 503 - &rdtgroup_default, "mon_groups", 504 504 - &kn_mongrp); 505 505 - if (ret < 0) 506 506 - goto out_info; 507 507 - 508 508 - ret = mkdir_mondata_all(rdtgroup_default.kn, 509 509 - &rdtgroup_default, &kn_mondata); 510 510 - if (ret < 0) 511 511 - goto out_mongrp; 512 512 - rdtgroup_default.mon.mon_data_kn = kn_mondata; 513 513 - } 514 514 - 515 515 - ret = rdt_pseudo_lock_init(); 516 516 - if (ret) 517 517 - goto out_mondata; 518 518 - 519 519 - ret = kernfs_get_tree(fc); 520 520 - if (ret < 0) 521 521 - goto out_psl; 522 522 - 523 523 - if (resctrl_arch_alloc_capable()) 524 524 - resctrl_arch_enable_alloc(); 525 525 - if (resctrl_arch_mon_capable()) 526 526 - resctrl_arch_enable_mon(); 527 527 - 528 528 - if (resctrl_arch_alloc_capable() || resctrl_arch_mon_capable()) 529 529 - resctrl_mounted = true; 530 530 - 531 531 - if (resctrl_is_mbm_enabled()) { 532 532 - r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 533 533 - list_for_each_entry(dom, &r->mon_domains, hdr.list) 534 534 - mbm_setup_overflow_handler(dom, MBM_OVERFLOW_INTERVAL, 535 535 - RESCTRL_PICK_ANY_CPU); 536 536 - } 537 537 - 538 538 - goto out; 539 539 - 540 540 - out_psl: 541 541 - rdt_pseudo_lock_release(); 542 542 - out_mondata: 543 543 - if (resctrl_arch_mon_capable()) 544 544 - kernfs_remove(kn_mondata); 545 545 - out_mongrp: 546 546 - if (resctrl_arch_mon_capable()) 547 547 - kernfs_remove(kn_mongrp); 548 548 - out_info: 549 549 - kernfs_remove(kn_info); 550 550 - out_schemata_free: 551 551 - schemata_list_destroy(); 552 552 - out_ctx: 553 553 - rdt_disable_ctx(); 554 554 - out_root: 555 555 - rdtgroup_destroy_root(); 556 556 - out: 557 557 - rdt_last_cmd_clear(); 558 558 - mutex_unlock(&rdtgroup_mutex); 559 559 - cpus_read_unlock(); 560 560 - return ret; 561 561 - } 562 562 - 563 563 - enum rdt_param { 564 564 - Opt_cdp, 565 565 - Opt_cdpl2, 566 566 - Opt_mba_mbps, 567 567 - Opt_debug, 568 568 - nr__rdt_params 569 569 - }; 570 570 - 571 571 - static const struct fs_parameter_spec rdt_fs_parameters[] = { 572 572 - fsparam_flag("cdp", Opt_cdp), 573 573 - fsparam_flag("cdpl2", Opt_cdpl2), 574 574 - fsparam_flag("mba_MBps", Opt_mba_mbps), 575 575 - fsparam_flag("debug", Opt_debug), 576 576 - {} 577 577 - }; 578 578 - 579 579 - static int rdt_parse_param(struct fs_context *fc, struct fs_parameter *param) 580 580 - { 581 581 - struct rdt_fs_context *ctx = rdt_fc2context(fc); 582 582 - struct fs_parse_result result; 583 583 - const char *msg; 584 584 - int opt; 585 585 - 586 586 - opt = fs_parse(fc, rdt_fs_parameters, param, &result); 587 587 - if (opt < 0) 588 588 - return opt; 589 589 - 590 590 - switch (opt) { 591 591 - case Opt_cdp: 592 592 - ctx->enable_cdpl3 = true; 593 593 - return 0; 594 594 - case Opt_cdpl2: 595 595 - ctx->enable_cdpl2 = true; 596 596 - return 0; 597 597 - case Opt_mba_mbps: 598 598 - msg = "mba_MBps requires MBM and linear scale MBA at L3 scope"; 599 599 - if (!supports_mba_mbps()) 600 600 - return invalfc(fc, msg); 601 601 - ctx->enable_mba_mbps = true; 602 602 - return 0; 603 603 - case Opt_debug: 604 604 - ctx->enable_debug = true; 605 605 - return 0; 606 606 - } 607 607 - 608 608 - return -EINVAL; 609 609 - } 610 610 - 611 611 - static void rdt_fs_context_free(struct fs_context *fc) 612 612 - { 613 613 - struct rdt_fs_context *ctx = rdt_fc2context(fc); 614 614 - 615 615 - kernfs_free_fs_context(fc); 616 616 - kfree(ctx); 617 617 - } 618 618 - 619 619 - static const struct fs_context_operations rdt_fs_context_ops = { 620 620 - .free = rdt_fs_context_free, 621 621 - .parse_param = rdt_parse_param, 622 622 - .get_tree = rdt_get_tree, 623 623 - }; 624 624 - 625 625 - static int rdt_init_fs_context(struct fs_context *fc) 626 626 - { 627 627 - struct rdt_fs_context *ctx; 628 628 - 629 629 - ctx = kzalloc(sizeof(struct rdt_fs_context), GFP_KERNEL); 630 630 - if (!ctx) 631 631 - return -ENOMEM; 632 632 - 633 633 - ctx->kfc.magic = RDTGROUP_SUPER_MAGIC; 634 634 - fc->fs_private = &ctx->kfc; 635 635 - fc->ops = &rdt_fs_context_ops; 636 636 - put_user_ns(fc->user_ns); 637 637 - fc->user_ns = get_user_ns(&init_user_ns); 638 638 - fc->global = true; 639 639 - return 0; 2512 2512 + return rdt_resources_all[l].cdp_enabled; 640 2513 } 641 2514 642 2515 void resctrl_arch_reset_all_ctrls(struct rdt_resource *r) ··· 259 2952 } 260 2953 261 2954 return; 262 262 - } 263 263 - 264 264 - /* 265 265 - * Move tasks from one to the other group. If @from is NULL, then all tasks 266 266 - * in the systems are moved unconditionally (used for teardown). 267 267 - * 268 268 - * If @mask is not NULL the cpus on which moved tasks are running are set 269 269 - * in that mask so the update smp function call is restricted to affected 270 270 - * cpus. 271 271 - */ 272 272 - static void rdt_move_group_tasks(struct rdtgroup *from, struct rdtgroup *to, 273 273 - struct cpumask *mask) 274 274 - { 275 275 - struct task_struct *p, *t; 276 276 - 277 277 - read_lock(&tasklist_lock); 278 278 - for_each_process_thread(p, t) { 279 279 - if (!from || is_closid_match(t, from) || 280 280 - is_rmid_match(t, from)) { 281 281 - resctrl_arch_set_closid_rmid(t, to->closid, 282 282 - to->mon.rmid); 283 283 - 284 284 - /* 285 285 - * Order the closid/rmid stores above before the loads 286 286 - * in task_curr(). This pairs with the full barrier 287 287 - * between the rq->curr update and resctrl_sched_in() 288 288 - * during context switch. 289 289 - */ 290 290 - smp_mb(); 291 291 - 292 292 - /* 293 293 - * If the task is on a CPU, set the CPU in the mask. 294 294 - * The detection is inaccurate as tasks might move or 295 295 - * schedule before the smp function call takes place. 296 296 - * In such a case the function call is pointless, but 297 297 - * there is no other side effect. 298 298 - */ 299 299 - if (IS_ENABLED(CONFIG_SMP) && mask && task_curr(t)) 300 300 - cpumask_set_cpu(task_cpu(t), mask); 301 301 - } 302 302 - } 303 303 - read_unlock(&tasklist_lock); 304 304 - } 305 305 - 306 306 - static void free_all_child_rdtgrp(struct rdtgroup *rdtgrp) 307 307 - { 308 308 - struct rdtgroup *sentry, *stmp; 309 309 - struct list_head *head; 310 310 - 311 311 - head = &rdtgrp->mon.crdtgrp_list; 312 312 - list_for_each_entry_safe(sentry, stmp, head, mon.crdtgrp_list) { 313 313 - free_rmid(sentry->closid, sentry->mon.rmid); 314 314 - list_del(&sentry->mon.crdtgrp_list); 315 315 - 316 316 - if (atomic_read(&sentry->waitcount) != 0) 317 317 - sentry->flags = RDT_DELETED; 318 318 - else 319 319 - rdtgroup_remove(sentry); 320 320 - } 321 321 - } 322 322 - 323 323 - /* 324 324 - * Forcibly remove all of subdirectories under root. 325 325 - */ 326 326 - static void rmdir_all_sub(void) 327 327 - { 328 328 - struct rdtgroup *rdtgrp, *tmp; 329 329 - 330 330 - /* Move all tasks to the default resource group */ 331 331 - rdt_move_group_tasks(NULL, &rdtgroup_default, NULL); 332 332 - 333 333 - list_for_each_entry_safe(rdtgrp, tmp, &rdt_all_groups, rdtgroup_list) { 334 334 - /* Free any child rmids */ 335 335 - free_all_child_rdtgrp(rdtgrp); 336 336 - 337 337 - /* Remove each rdtgroup other than root */ 338 338 - if (rdtgrp == &rdtgroup_default) 339 339 - continue; 340 340 - 341 341 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 342 342 - rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 343 343 - rdtgroup_pseudo_lock_remove(rdtgrp); 344 344 - 345 345 - /* 346 346 - * Give any CPUs back to the default group. We cannot copy 347 347 - * cpu_online_mask because a CPU might have executed the 348 348 - * offline callback already, but is still marked online. 349 349 - */ 350 350 - cpumask_or(&rdtgroup_default.cpu_mask, 351 351 - &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 352 352 - 353 353 - free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 354 354 - 355 355 - kernfs_remove(rdtgrp->kn); 356 356 - list_del(&rdtgrp->rdtgroup_list); 357 357 - 358 358 - if (atomic_read(&rdtgrp->waitcount) != 0) 359 359 - rdtgrp->flags = RDT_DELETED; 360 360 - else 361 361 - rdtgroup_remove(rdtgrp); 362 362 - } 363 363 - /* Notify online CPUs to update per cpu storage and PQR_ASSOC MSR */ 364 364 - update_closid_rmid(cpu_online_mask, &rdtgroup_default); 365 365 - 366 366 - kernfs_remove(kn_info); 367 367 - kernfs_remove(kn_mongrp); 368 368 - kernfs_remove(kn_mondata); 369 369 - } 370 370 - 371 371 - static void rdt_kill_sb(struct super_block *sb) 372 372 - { 373 373 - struct rdt_resource *r; 374 374 - 375 375 - cpus_read_lock(); 376 376 - mutex_lock(&rdtgroup_mutex); 377 377 - 378 378 - rdt_disable_ctx(); 379 379 - 380 380 - /* Put everything back to default values. */ 381 381 - for_each_alloc_capable_rdt_resource(r) 382 382 - resctrl_arch_reset_all_ctrls(r); 383 383 - 384 384 - rmdir_all_sub(); 385 385 - rdt_pseudo_lock_release(); 386 386 - rdtgroup_default.mode = RDT_MODE_SHAREABLE; 387 387 - schemata_list_destroy(); 388 388 - rdtgroup_destroy_root(); 389 389 - if (resctrl_arch_alloc_capable()) 390 390 - resctrl_arch_disable_alloc(); 391 391 - if (resctrl_arch_mon_capable()) 392 392 - resctrl_arch_disable_mon(); 393 393 - resctrl_mounted = false; 394 394 - kernfs_kill_sb(sb); 395 395 - mutex_unlock(&rdtgroup_mutex); 396 396 - cpus_read_unlock(); 397 397 - } 398 398 - 399 399 - static struct file_system_type rdt_fs_type = { 400 400 - .name = "resctrl", 401 401 - .init_fs_context = rdt_init_fs_context, 402 402 - .parameters = rdt_fs_parameters, 403 403 - .kill_sb = rdt_kill_sb, 404 404 - }; 405 405 - 406 406 - static int mon_addfile(struct kernfs_node *parent_kn, const char *name, 407 407 - void *priv) 408 408 - { 409 409 - struct kernfs_node *kn; 410 410 - int ret = 0; 411 411 - 412 412 - kn = __kernfs_create_file(parent_kn, name, 0444, 413 413 - GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 0, 414 414 - &kf_mondata_ops, priv, NULL, NULL); 415 415 - if (IS_ERR(kn)) 416 416 - return PTR_ERR(kn); 417 417 - 418 418 - ret = rdtgroup_kn_set_ugid(kn); 419 419 - if (ret) { 420 420 - kernfs_remove(kn); 421 421 - return ret; 422 422 - } 423 423 - 424 424 - return ret; 425 425 - } 426 426 - 427 427 - static void mon_rmdir_one_subdir(struct kernfs_node *pkn, char *name, char *subname) 428 428 - { 429 429 - struct kernfs_node *kn; 430 430 - 431 431 - kn = kernfs_find_and_get(pkn, name); 432 432 - if (!kn) 433 433 - return; 434 434 - kernfs_put(kn); 435 435 - 436 436 - if (kn->dir.subdirs <= 1) 437 437 - kernfs_remove(kn); 438 438 - else 439 439 - kernfs_remove_by_name(kn, subname); 440 440 - } 441 441 - 442 442 - /* 443 443 - * Remove all subdirectories of mon_data of ctrl_mon groups 444 444 - * and monitor groups for the given domain. 445 445 - * Remove files and directories containing "sum" of domain data 446 446 - * when last domain being summed is removed. 447 447 - */ 448 448 - static void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 449 449 - struct rdt_mon_domain *d) 450 450 - { 451 451 - struct rdtgroup *prgrp, *crgrp; 452 452 - char subname[32]; 453 453 - bool snc_mode; 454 454 - char name[32]; 455 455 - 456 456 - snc_mode = r->mon_scope == RESCTRL_L3_NODE; 457 457 - sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci->id : d->hdr.id); 458 458 - if (snc_mode) 459 459 - sprintf(subname, "mon_sub_%s_%02d", r->name, d->hdr.id); 460 460 - 461 461 - list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 462 462 - mon_rmdir_one_subdir(prgrp->mon.mon_data_kn, name, subname); 463 463 - 464 464 - list_for_each_entry(crgrp, &prgrp->mon.crdtgrp_list, mon.crdtgrp_list) 465 465 - mon_rmdir_one_subdir(crgrp->mon.mon_data_kn, name, subname); 466 466 - } 467 467 - } 468 468 - 469 469 - static int mon_add_all_files(struct kernfs_node *kn, struct rdt_mon_domain *d, 470 470 - struct rdt_resource *r, struct rdtgroup *prgrp, 471 471 - bool do_sum) 472 472 - { 473 473 - struct rmid_read rr = {0}; 474 474 - union mon_data_bits priv; 475 475 - struct mon_evt *mevt; 476 476 - int ret; 477 477 - 478 478 - if (WARN_ON(list_empty(&r->evt_list))) 479 479 - return -EPERM; 480 480 - 481 481 - priv.u.rid = r->rid; 482 482 - priv.u.domid = do_sum ? d->ci->id : d->hdr.id; 483 483 - priv.u.sum = do_sum; 484 484 - list_for_each_entry(mevt, &r->evt_list, list) { 485 485 - priv.u.evtid = mevt->evtid; 486 486 - ret = mon_addfile(kn, mevt->name, priv.priv); 487 487 - if (ret) 488 488 - return ret; 489 489 - 490 490 - if (!do_sum && resctrl_is_mbm_event(mevt->evtid)) 491 491 - mon_event_read(&rr, r, d, prgrp, &d->hdr.cpu_mask, mevt->evtid, true); 492 492 - } 493 493 - 494 494 - return 0; 495 495 - } 496 496 - 497 497 - static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, 498 498 - struct rdt_mon_domain *d, 499 499 - struct rdt_resource *r, struct rdtgroup *prgrp) 500 500 - { 501 501 - struct kernfs_node *kn, *ckn; 502 502 - char name[32]; 503 503 - bool snc_mode; 504 504 - int ret = 0; 505 505 - 506 506 - lockdep_assert_held(&rdtgroup_mutex); 507 507 - 508 508 - snc_mode = r->mon_scope == RESCTRL_L3_NODE; 509 509 - sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci->id : d->hdr.id); 510 510 - kn = kernfs_find_and_get(parent_kn, name); 511 511 - if (kn) { 512 512 - /* 513 513 - * rdtgroup_mutex will prevent this directory from being 514 514 - * removed. No need to keep this hold. 515 515 - */ 516 516 - kernfs_put(kn); 517 517 - } else { 518 518 - kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 519 519 - if (IS_ERR(kn)) 520 520 - return PTR_ERR(kn); 521 521 - 522 522 - ret = rdtgroup_kn_set_ugid(kn); 523 523 - if (ret) 524 524 - goto out_destroy; 525 525 - ret = mon_add_all_files(kn, d, r, prgrp, snc_mode); 526 526 - if (ret) 527 527 - goto out_destroy; 528 528 - } 529 529 - 530 530 - if (snc_mode) { 531 531 - sprintf(name, "mon_sub_%s_%02d", r->name, d->hdr.id); 532 532 - ckn = kernfs_create_dir(kn, name, parent_kn->mode, prgrp); 533 533 - if (IS_ERR(ckn)) { 534 534 - ret = -EINVAL; 535 535 - goto out_destroy; 536 536 - } 537 537 - 538 538 - ret = rdtgroup_kn_set_ugid(ckn); 539 539 - if (ret) 540 540 - goto out_destroy; 541 541 - 542 542 - ret = mon_add_all_files(ckn, d, r, prgrp, false); 543 543 - if (ret) 544 544 - goto out_destroy; 545 545 - } 546 546 - 547 547 - kernfs_activate(kn); 548 548 - return 0; 549 549 - 550 550 - out_destroy: 551 551 - kernfs_remove(kn); 552 552 - return ret; 553 553 - } 554 554 - 555 555 - /* 556 556 - * Add all subdirectories of mon_data for "ctrl_mon" groups 557 557 - * and "monitor" groups with given domain id. 558 558 - */ 559 559 - static void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 560 560 - struct rdt_mon_domain *d) 561 561 - { 562 562 - struct kernfs_node *parent_kn; 563 563 - struct rdtgroup *prgrp, *crgrp; 564 564 - struct list_head *head; 565 565 - 566 566 - list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 567 567 - parent_kn = prgrp->mon.mon_data_kn; 568 568 - mkdir_mondata_subdir(parent_kn, d, r, prgrp); 569 569 - 570 570 - head = &prgrp->mon.crdtgrp_list; 571 571 - list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 572 572 - parent_kn = crgrp->mon.mon_data_kn; 573 573 - mkdir_mondata_subdir(parent_kn, d, r, crgrp); 574 574 - } 575 575 - } 576 576 - } 577 577 - 578 578 - static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, 579 579 - struct rdt_resource *r, 580 580 - struct rdtgroup *prgrp) 581 581 - { 582 582 - struct rdt_mon_domain *dom; 583 583 - int ret; 584 584 - 585 585 - /* Walking r->domains, ensure it can't race with cpuhp */ 586 586 - lockdep_assert_cpus_held(); 587 587 - 588 588 - list_for_each_entry(dom, &r->mon_domains, hdr.list) { 589 589 - ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp); 590 590 - if (ret) 591 591 - return ret; 592 592 - } 593 593 - 594 594 - return 0; 595 595 - } 596 596 - 597 597 - /* 598 598 - * This creates a directory mon_data which contains the monitored data. 599 599 - * 600 600 - * mon_data has one directory for each domain which are named 601 601 - * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data 602 602 - * with L3 domain looks as below: 603 603 - * ./mon_data: 604 604 - * mon_L3_00 605 605 - * mon_L3_01 606 606 - * mon_L3_02 607 607 - * ... 608 608 - * 609 609 - * Each domain directory has one file per event: 610 610 - * ./mon_L3_00/: 611 611 - * llc_occupancy 612 612 - * 613 613 - */ 614 614 - static int mkdir_mondata_all(struct kernfs_node *parent_kn, 615 615 - struct rdtgroup *prgrp, 616 616 - struct kernfs_node **dest_kn) 617 617 - { 618 618 - struct rdt_resource *r; 619 619 - struct kernfs_node *kn; 620 620 - int ret; 621 621 - 622 622 - /* 623 623 - * Create the mon_data directory first. 624 624 - */ 625 625 - ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn); 626 626 - if (ret) 627 627 - return ret; 628 628 - 629 629 - if (dest_kn) 630 630 - *dest_kn = kn; 631 631 - 632 632 - /* 633 633 - * Create the subdirectories for each domain. Note that all events 634 634 - * in a domain like L3 are grouped into a resource whose domain is L3 635 635 - */ 636 636 - for_each_mon_capable_rdt_resource(r) { 637 637 - ret = mkdir_mondata_subdir_alldom(kn, r, prgrp); 638 638 - if (ret) 639 639 - goto out_destroy; 640 640 - } 641 641 - 642 642 - return 0; 643 643 - 644 644 - out_destroy: 645 645 - kernfs_remove(kn); 646 646 - return ret; 647 647 - } 648 648 - 649 649 - /** 650 650 - * cbm_ensure_valid - Enforce validity on provided CBM 651 651 - * @_val: Candidate CBM 652 652 - * @r: RDT resource to which the CBM belongs 653 653 - * 654 654 - * The provided CBM represents all cache portions available for use. This 655 655 - * may be represented by a bitmap that does not consist of contiguous ones 656 656 - * and thus be an invalid CBM. 657 657 - * Here the provided CBM is forced to be a valid CBM by only considering 658 658 - * the first set of contiguous bits as valid and clearing all bits. 659 659 - * The intention here is to provide a valid default CBM with which a new 660 660 - * resource group is initialized. The user can follow this with a 661 661 - * modification to the CBM if the default does not satisfy the 662 662 - * requirements. 663 663 - */ 664 664 - static u32 cbm_ensure_valid(u32 _val, struct rdt_resource *r) 665 665 - { 666 666 - unsigned int cbm_len = r->cache.cbm_len; 667 667 - unsigned long first_bit, zero_bit; 668 668 - unsigned long val = _val; 669 669 - 670 670 - if (!val) 671 671 - return 0; 672 672 - 673 673 - first_bit = find_first_bit(&val, cbm_len); 674 674 - zero_bit = find_next_zero_bit(&val, cbm_len, first_bit); 675 675 - 676 676 - /* Clear any remaining bits to ensure contiguous region */ 677 677 - bitmap_clear(&val, zero_bit, cbm_len - zero_bit); 678 678 - return (u32)val; 679 679 - } 680 680 - 681 681 - /* 682 682 - * Initialize cache resources per RDT domain 683 683 - * 684 684 - * Set the RDT domain up to start off with all usable allocations. That is, 685 685 - * all shareable and unused bits. All-zero CBM is invalid. 686 686 - */ 687 687 - static int __init_one_rdt_domain(struct rdt_ctrl_domain *d, struct resctrl_schema *s, 688 688 - u32 closid) 689 689 - { 690 690 - enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 691 691 - enum resctrl_conf_type t = s->conf_type; 692 692 - struct resctrl_staged_config *cfg; 693 693 - struct rdt_resource *r = s->res; 694 694 - u32 used_b = 0, unused_b = 0; 695 695 - unsigned long tmp_cbm; 696 696 - enum rdtgrp_mode mode; 697 697 - u32 peer_ctl, ctrl_val; 698 698 - int i; 699 699 - 700 700 - cfg = &d->staged_config[t]; 701 701 - cfg->have_new_ctrl = false; 702 702 - cfg->new_ctrl = r->cache.shareable_bits; 703 703 - used_b = r->cache.shareable_bits; 704 704 - for (i = 0; i < closids_supported(); i++) { 705 705 - if (closid_allocated(i) && i != closid) { 706 706 - mode = rdtgroup_mode_by_closid(i); 707 707 - if (mode == RDT_MODE_PSEUDO_LOCKSETUP) 708 708 - /* 709 709 - * ctrl values for locksetup aren't relevant 710 710 - * until the schemata is written, and the mode 711 711 - * becomes RDT_MODE_PSEUDO_LOCKED. 712 712 - */ 713 713 - continue; 714 714 - /* 715 715 - * If CDP is active include peer domain's 716 716 - * usage to ensure there is no overlap 717 717 - * with an exclusive group. 718 718 - */ 719 719 - if (resctrl_arch_get_cdp_enabled(r->rid)) 720 720 - peer_ctl = resctrl_arch_get_config(r, d, i, 721 721 - peer_type); 722 722 - else 723 723 - peer_ctl = 0; 724 724 - ctrl_val = resctrl_arch_get_config(r, d, i, 725 725 - s->conf_type); 726 726 - used_b |= ctrl_val | peer_ctl; 727 727 - if (mode == RDT_MODE_SHAREABLE) 728 728 - cfg->new_ctrl |= ctrl_val | peer_ctl; 729 729 - } 730 730 - } 731 731 - if (d->plr && d->plr->cbm > 0) 732 732 - used_b |= d->plr->cbm; 733 733 - unused_b = used_b ^ (BIT_MASK(r->cache.cbm_len) - 1); 734 734 - unused_b &= BIT_MASK(r->cache.cbm_len) - 1; 735 735 - cfg->new_ctrl |= unused_b; 736 736 - /* 737 737 - * Force the initial CBM to be valid, user can 738 738 - * modify the CBM based on system availability. 739 739 - */ 740 740 - cfg->new_ctrl = cbm_ensure_valid(cfg->new_ctrl, r); 741 741 - /* 742 742 - * Assign the u32 CBM to an unsigned long to ensure that 743 743 - * bitmap_weight() does not access out-of-bound memory. 744 744 - */ 745 745 - tmp_cbm = cfg->new_ctrl; 746 746 - if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) { 747 747 - rdt_last_cmd_printf("No space on %s:%d\n", s->name, d->hdr.id); 748 748 - return -ENOSPC; 749 749 - } 750 750 - cfg->have_new_ctrl = true; 751 751 - 752 752 - return 0; 753 753 - } 754 754 - 755 755 - /* 756 756 - * Initialize cache resources with default values. 757 757 - * 758 758 - * A new RDT group is being created on an allocation capable (CAT) 759 759 - * supporting system. Set this group up to start off with all usable 760 760 - * allocations. 761 761 - * 762 762 - * If there are no more shareable bits available on any domain then 763 763 - * the entire allocation will fail. 764 764 - */ 765 765 - static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) 766 766 - { 767 767 - struct rdt_ctrl_domain *d; 768 768 - int ret; 769 769 - 770 770 - list_for_each_entry(d, &s->res->ctrl_domains, hdr.list) { 771 771 - ret = __init_one_rdt_domain(d, s, closid); 772 772 - if (ret < 0) 773 773 - return ret; 774 774 - } 775 775 - 776 776 - return 0; 777 777 - } 778 778 - 779 779 - /* Initialize MBA resource with default values. */ 780 780 - static void rdtgroup_init_mba(struct rdt_resource *r, u32 closid) 781 781 - { 782 782 - struct resctrl_staged_config *cfg; 783 783 - struct rdt_ctrl_domain *d; 784 784 - 785 785 - list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 786 786 - if (is_mba_sc(r)) { 787 787 - d->mbps_val[closid] = MBA_MAX_MBPS; 788 788 - continue; 789 789 - } 790 790 - 791 791 - cfg = &d->staged_config[CDP_NONE]; 792 792 - cfg->new_ctrl = resctrl_get_default_ctrl(r); 793 793 - cfg->have_new_ctrl = true; 794 794 - } 795 795 - } 796 796 - 797 797 - /* Initialize the RDT group's allocations. */ 798 798 - static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp) 799 799 - { 800 800 - struct resctrl_schema *s; 801 801 - struct rdt_resource *r; 802 802 - int ret = 0; 803 803 - 804 804 - rdt_staged_configs_clear(); 805 805 - 806 806 - list_for_each_entry(s, &resctrl_schema_all, list) { 807 807 - r = s->res; 808 808 - if (r->rid == RDT_RESOURCE_MBA || 809 809 - r->rid == RDT_RESOURCE_SMBA) { 810 810 - rdtgroup_init_mba(r, rdtgrp->closid); 811 811 - if (is_mba_sc(r)) 812 812 - continue; 813 813 - } else { 814 814 - ret = rdtgroup_init_cat(s, rdtgrp->closid); 815 815 - if (ret < 0) 816 816 - goto out; 817 817 - } 818 818 - 819 819 - ret = resctrl_arch_update_domains(r, rdtgrp->closid); 820 820 - if (ret < 0) { 821 821 - rdt_last_cmd_puts("Failed to initialize allocations\n"); 822 822 - goto out; 823 823 - } 824 824 - 825 825 - } 826 826 - 827 827 - rdtgrp->mode = RDT_MODE_SHAREABLE; 828 828 - 829 829 - out: 830 830 - rdt_staged_configs_clear(); 831 831 - return ret; 832 832 - } 833 833 - 834 834 - static int mkdir_rdt_prepare_rmid_alloc(struct rdtgroup *rdtgrp) 835 835 - { 836 836 - int ret; 837 837 - 838 838 - if (!resctrl_arch_mon_capable()) 839 839 - return 0; 840 840 - 841 841 - ret = alloc_rmid(rdtgrp->closid); 842 842 - if (ret < 0) { 843 843 - rdt_last_cmd_puts("Out of RMIDs\n"); 844 844 - return ret; 845 845 - } 846 846 - rdtgrp->mon.rmid = ret; 847 847 - 848 848 - ret = mkdir_mondata_all(rdtgrp->kn, rdtgrp, &rdtgrp->mon.mon_data_kn); 849 849 - if (ret) { 850 850 - rdt_last_cmd_puts("kernfs subdir error\n"); 851 851 - free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 852 852 - return ret; 853 853 - } 854 854 - 855 855 - return 0; 856 856 - } 857 857 - 858 858 - static void mkdir_rdt_prepare_rmid_free(struct rdtgroup *rgrp) 859 859 - { 860 860 - if (resctrl_arch_mon_capable()) 861 861 - free_rmid(rgrp->closid, rgrp->mon.rmid); 862 862 - } 863 863 - 864 864 - /* 865 865 - * We allow creating mon groups only with in a directory called "mon_groups" 866 866 - * which is present in every ctrl_mon group. Check if this is a valid 867 867 - * "mon_groups" directory. 868 868 - * 869 869 - * 1. The directory should be named "mon_groups". 870 870 - * 2. The mon group itself should "not" be named "mon_groups". 871 871 - * This makes sure "mon_groups" directory always has a ctrl_mon group 872 872 - * as parent. 873 873 - */ 874 874 - static bool is_mon_groups(struct kernfs_node *kn, const char *name) 875 875 - { 876 876 - return (!strcmp(rdt_kn_name(kn), "mon_groups") && 877 877 - strcmp(name, "mon_groups")); 878 878 - } 879 879 - 880 880 - static int mkdir_rdt_prepare(struct kernfs_node *parent_kn, 881 881 - const char *name, umode_t mode, 882 882 - enum rdt_group_type rtype, struct rdtgroup **r) 883 883 - { 884 884 - struct rdtgroup *prdtgrp, *rdtgrp; 885 885 - unsigned long files = 0; 886 886 - struct kernfs_node *kn; 887 887 - int ret; 888 888 - 889 889 - prdtgrp = rdtgroup_kn_lock_live(parent_kn); 890 890 - if (!prdtgrp) { 891 891 - ret = -ENODEV; 892 892 - goto out_unlock; 893 893 - } 894 894 - 895 895 - /* 896 896 - * Check that the parent directory for a monitor group is a "mon_groups" 897 897 - * directory. 898 898 - */ 899 899 - if (rtype == RDTMON_GROUP && !is_mon_groups(parent_kn, name)) { 900 900 - ret = -EPERM; 901 901 - goto out_unlock; 902 902 - } 903 903 - 904 904 - if (rtype == RDTMON_GROUP && 905 905 - (prdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 906 906 - prdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)) { 907 907 - ret = -EINVAL; 908 908 - rdt_last_cmd_puts("Pseudo-locking in progress\n"); 909 909 - goto out_unlock; 910 910 - } 911 911 - 912 912 - /* allocate the rdtgroup. */ 913 913 - rdtgrp = kzalloc(sizeof(*rdtgrp), GFP_KERNEL); 914 914 - if (!rdtgrp) { 915 915 - ret = -ENOSPC; 916 916 - rdt_last_cmd_puts("Kernel out of memory\n"); 917 917 - goto out_unlock; 918 918 - } 919 919 - *r = rdtgrp; 920 920 - rdtgrp->mon.parent = prdtgrp; 921 921 - rdtgrp->type = rtype; 922 922 - INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list); 923 923 - 924 924 - /* kernfs creates the directory for rdtgrp */ 925 925 - kn = kernfs_create_dir(parent_kn, name, mode, rdtgrp); 926 926 - if (IS_ERR(kn)) { 927 927 - ret = PTR_ERR(kn); 928 928 - rdt_last_cmd_puts("kernfs create error\n"); 929 929 - goto out_free_rgrp; 930 930 - } 931 931 - rdtgrp->kn = kn; 932 932 - 933 933 - /* 934 934 - * kernfs_remove() will drop the reference count on "kn" which 935 935 - * will free it. But we still need it to stick around for the 936 936 - * rdtgroup_kn_unlock(kn) call. Take one extra reference here, 937 937 - * which will be dropped by kernfs_put() in rdtgroup_remove(). 938 938 - */ 939 939 - kernfs_get(kn); 940 940 - 941 941 - ret = rdtgroup_kn_set_ugid(kn); 942 942 - if (ret) { 943 943 - rdt_last_cmd_puts("kernfs perm error\n"); 944 944 - goto out_destroy; 945 945 - } 946 946 - 947 947 - if (rtype == RDTCTRL_GROUP) { 948 948 - files = RFTYPE_BASE | RFTYPE_CTRL; 949 949 - if (resctrl_arch_mon_capable()) 950 950 - files |= RFTYPE_MON; 951 951 - } else { 952 952 - files = RFTYPE_BASE | RFTYPE_MON; 953 953 - } 954 954 - 955 955 - ret = rdtgroup_add_files(kn, files); 956 956 - if (ret) { 957 957 - rdt_last_cmd_puts("kernfs fill error\n"); 958 958 - goto out_destroy; 959 959 - } 960 960 - 961 961 - /* 962 962 - * The caller unlocks the parent_kn upon success. 963 963 - */ 964 964 - return 0; 965 965 - 966 966 - out_destroy: 967 967 - kernfs_put(rdtgrp->kn); 968 968 - kernfs_remove(rdtgrp->kn); 969 969 - out_free_rgrp: 970 970 - kfree(rdtgrp); 971 971 - out_unlock: 972 972 - rdtgroup_kn_unlock(parent_kn); 973 973 - return ret; 974 974 - } 975 975 - 976 976 - static void mkdir_rdt_prepare_clean(struct rdtgroup *rgrp) 977 977 - { 978 978 - kernfs_remove(rgrp->kn); 979 979 - rdtgroup_remove(rgrp); 980 980 - } 981 981 - 982 982 - /* 983 983 - * Create a monitor group under "mon_groups" directory of a control 984 984 - * and monitor group(ctrl_mon). This is a resource group 985 985 - * to monitor a subset of tasks and cpus in its parent ctrl_mon group. 986 986 - */ 987 987 - static int rdtgroup_mkdir_mon(struct kernfs_node *parent_kn, 988 988 - const char *name, umode_t mode) 989 989 - { 990 990 - struct rdtgroup *rdtgrp, *prgrp; 991 991 - int ret; 992 992 - 993 993 - ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTMON_GROUP, &rdtgrp); 994 994 - if (ret) 995 995 - return ret; 996 996 - 997 997 - prgrp = rdtgrp->mon.parent; 998 998 - rdtgrp->closid = prgrp->closid; 999 999 - 1000 1000 - ret = mkdir_rdt_prepare_rmid_alloc(rdtgrp); 1001 1001 - if (ret) { 1002 1002 - mkdir_rdt_prepare_clean(rdtgrp); 1003 1003 - goto out_unlock; 1004 1004 - } 1005 1005 - 1006 1006 - kernfs_activate(rdtgrp->kn); 1007 1007 - 1008 1008 - /* 1009 1009 - * Add the rdtgrp to the list of rdtgrps the parent 1010 1010 - * ctrl_mon group has to track. 1011 1011 - */ 1012 1012 - list_add_tail(&rdtgrp->mon.crdtgrp_list, &prgrp->mon.crdtgrp_list); 1013 1013 - 1014 1014 - out_unlock: 1015 1015 - rdtgroup_kn_unlock(parent_kn); 1016 1016 - return ret; 1017 1017 - } 1018 1018 - 1019 1019 - /* 1020 1020 - * These are rdtgroups created under the root directory. Can be used 1021 1021 - * to allocate and monitor resources. 1022 1022 - */ 1023 1023 - static int rdtgroup_mkdir_ctrl_mon(struct kernfs_node *parent_kn, 1024 1024 - const char *name, umode_t mode) 1025 1025 - { 1026 1026 - struct rdtgroup *rdtgrp; 1027 1027 - struct kernfs_node *kn; 1028 1028 - u32 closid; 1029 1029 - int ret; 1030 1030 - 1031 1031 - ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTCTRL_GROUP, &rdtgrp); 1032 1032 - if (ret) 1033 1033 - return ret; 1034 1034 - 1035 1035 - kn = rdtgrp->kn; 1036 1036 - ret = closid_alloc(); 1037 1037 - if (ret < 0) { 1038 1038 - rdt_last_cmd_puts("Out of CLOSIDs\n"); 1039 1039 - goto out_common_fail; 1040 1040 - } 1041 1041 - closid = ret; 1042 1042 - ret = 0; 1043 1043 - 1044 1044 - rdtgrp->closid = closid; 1045 1045 - 1046 1046 - ret = mkdir_rdt_prepare_rmid_alloc(rdtgrp); 1047 1047 - if (ret) 1048 1048 - goto out_closid_free; 1049 1049 - 1050 1050 - kernfs_activate(rdtgrp->kn); 1051 1051 - 1052 1052 - ret = rdtgroup_init_alloc(rdtgrp); 1053 1053 - if (ret < 0) 1054 1054 - goto out_rmid_free; 1055 1055 - 1056 1056 - list_add(&rdtgrp->rdtgroup_list, &rdt_all_groups); 1057 1057 - 1058 1058 - if (resctrl_arch_mon_capable()) { 1059 1059 - /* 1060 1060 - * Create an empty mon_groups directory to hold the subset 1061 1061 - * of tasks and cpus to monitor. 1062 1062 - */ 1063 1063 - ret = mongroup_create_dir(kn, rdtgrp, "mon_groups", NULL); 1064 1064 - if (ret) { 1065 1065 - rdt_last_cmd_puts("kernfs subdir error\n"); 1066 1066 - goto out_del_list; 1067 1067 - } 1068 1068 - if (is_mba_sc(NULL)) 1069 1069 - rdtgrp->mba_mbps_event = mba_mbps_default_event; 1070 1070 - } 1071 1071 - 1072 1072 - goto out_unlock; 1073 1073 - 1074 1074 - out_del_list: 1075 1075 - list_del(&rdtgrp->rdtgroup_list); 1076 1076 - out_rmid_free: 1077 1077 - mkdir_rdt_prepare_rmid_free(rdtgrp); 1078 1078 - out_closid_free: 1079 1079 - closid_free(closid); 1080 1080 - out_common_fail: 1081 1081 - mkdir_rdt_prepare_clean(rdtgrp); 1082 1082 - out_unlock: 1083 1083 - rdtgroup_kn_unlock(parent_kn); 1084 1084 - return ret; 1085 1085 - } 1086 1086 - 1087 1087 - static int rdtgroup_mkdir(struct kernfs_node *parent_kn, const char *name, 1088 1088 - umode_t mode) 1089 1089 - { 1090 1090 - /* Do not accept '\n' to avoid unparsable situation. */ 1091 1091 - if (strchr(name, '\n')) 1092 1092 - return -EINVAL; 1093 1093 - 1094 1094 - /* 1095 1095 - * If the parent directory is the root directory and RDT 1096 1096 - * allocation is supported, add a control and monitoring 1097 1097 - * subdirectory 1098 1098 - */ 1099 1099 - if (resctrl_arch_alloc_capable() && parent_kn == rdtgroup_default.kn) 1100 1100 - return rdtgroup_mkdir_ctrl_mon(parent_kn, name, mode); 1101 1101 - 1102 1102 - /* Else, attempt to add a monitoring subdirectory. */ 1103 1103 - if (resctrl_arch_mon_capable()) 1104 1104 - return rdtgroup_mkdir_mon(parent_kn, name, mode); 1105 1105 - 1106 1106 - return -EPERM; 1107 1107 - } 1108 1108 - 1109 1109 - static int rdtgroup_rmdir_mon(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 1110 1110 - { 1111 1111 - struct rdtgroup *prdtgrp = rdtgrp->mon.parent; 1112 1112 - u32 closid, rmid; 1113 1113 - int cpu; 1114 1114 - 1115 1115 - /* Give any tasks back to the parent group */ 1116 1116 - rdt_move_group_tasks(rdtgrp, prdtgrp, tmpmask); 1117 1117 - 1118 1118 - /* 1119 1119 - * Update per cpu closid/rmid of the moved CPUs first. 1120 1120 - * Note: the closid will not change, but the arch code still needs it. 1121 1121 - */ 1122 1122 - closid = prdtgrp->closid; 1123 1123 - rmid = prdtgrp->mon.rmid; 1124 1124 - for_each_cpu(cpu, &rdtgrp->cpu_mask) 1125 1125 - resctrl_arch_set_cpu_default_closid_rmid(cpu, closid, rmid); 1126 1126 - 1127 1127 - /* 1128 1128 - * Update the MSR on moved CPUs and CPUs which have moved 1129 1129 - * task running on them. 1130 1130 - */ 1131 1131 - cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 1132 1132 - update_closid_rmid(tmpmask, NULL); 1133 1133 - 1134 1134 - rdtgrp->flags = RDT_DELETED; 1135 1135 - free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 1136 1136 - 1137 1137 - /* 1138 1138 - * Remove the rdtgrp from the parent ctrl_mon group's list 1139 1139 - */ 1140 1140 - WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list)); 1141 1141 - list_del(&rdtgrp->mon.crdtgrp_list); 1142 1142 - 1143 1143 - kernfs_remove(rdtgrp->kn); 1144 1144 - 1145 1145 - return 0; 1146 1146 - } 1147 1147 - 1148 1148 - static int rdtgroup_ctrl_remove(struct rdtgroup *rdtgrp) 1149 1149 - { 1150 1150 - rdtgrp->flags = RDT_DELETED; 1151 1151 - list_del(&rdtgrp->rdtgroup_list); 1152 1152 - 1153 1153 - kernfs_remove(rdtgrp->kn); 1154 1154 - return 0; 1155 1155 - } 1156 1156 - 1157 1157 - static int rdtgroup_rmdir_ctrl(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 1158 1158 - { 1159 1159 - u32 closid, rmid; 1160 1160 - int cpu; 1161 1161 - 1162 1162 - /* Give any tasks back to the default group */ 1163 1163 - rdt_move_group_tasks(rdtgrp, &rdtgroup_default, tmpmask); 1164 1164 - 1165 1165 - /* Give any CPUs back to the default group */ 1166 1166 - cpumask_or(&rdtgroup_default.cpu_mask, 1167 1167 - &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 1168 1168 - 1169 1169 - /* Update per cpu closid and rmid of the moved CPUs first */ 1170 1170 - closid = rdtgroup_default.closid; 1171 1171 - rmid = rdtgroup_default.mon.rmid; 1172 1172 - for_each_cpu(cpu, &rdtgrp->cpu_mask) 1173 1173 - resctrl_arch_set_cpu_default_closid_rmid(cpu, closid, rmid); 1174 1174 - 1175 1175 - /* 1176 1176 - * Update the MSR on moved CPUs and CPUs which have moved 1177 1177 - * task running on them. 1178 1178 - */ 1179 1179 - cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 1180 1180 - update_closid_rmid(tmpmask, NULL); 1181 1181 - 1182 1182 - free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 1183 1183 - closid_free(rdtgrp->closid); 1184 1184 - 1185 1185 - rdtgroup_ctrl_remove(rdtgrp); 1186 1186 - 1187 1187 - /* 1188 1188 - * Free all the child monitor group rmids. 1189 1189 - */ 1190 1190 - free_all_child_rdtgrp(rdtgrp); 1191 1191 - 1192 1192 - return 0; 1193 1193 - } 1194 1194 - 1195 1195 - static struct kernfs_node *rdt_kn_parent(struct kernfs_node *kn) 1196 1196 - { 1197 1197 - /* 1198 1198 - * Valid within the RCU section it was obtained or while rdtgroup_mutex 1199 1199 - * is held. 1200 1200 - */ 1201 1201 - return rcu_dereference_check(kn->__parent, lockdep_is_held(&rdtgroup_mutex)); 1202 1202 - } 1203 1203 - 1204 1204 - static int rdtgroup_rmdir(struct kernfs_node *kn) 1205 1205 - { 1206 1206 - struct kernfs_node *parent_kn; 1207 1207 - struct rdtgroup *rdtgrp; 1208 1208 - cpumask_var_t tmpmask; 1209 1209 - int ret = 0; 1210 1210 - 1211 1211 - if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 1212 1212 - return -ENOMEM; 1213 1213 - 1214 1214 - rdtgrp = rdtgroup_kn_lock_live(kn); 1215 1215 - if (!rdtgrp) { 1216 1216 - ret = -EPERM; 1217 1217 - goto out; 1218 1218 - } 1219 1219 - parent_kn = rdt_kn_parent(kn); 1220 1220 - 1221 1221 - /* 1222 1222 - * If the rdtgroup is a ctrl_mon group and parent directory 1223 1223 - * is the root directory, remove the ctrl_mon group. 1224 1224 - * 1225 1225 - * If the rdtgroup is a mon group and parent directory 1226 1226 - * is a valid "mon_groups" directory, remove the mon group. 1227 1227 - */ 1228 1228 - if (rdtgrp->type == RDTCTRL_GROUP && parent_kn == rdtgroup_default.kn && 1229 1229 - rdtgrp != &rdtgroup_default) { 1230 1230 - if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 1231 1231 - rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 1232 1232 - ret = rdtgroup_ctrl_remove(rdtgrp); 1233 1233 - } else { 1234 1234 - ret = rdtgroup_rmdir_ctrl(rdtgrp, tmpmask); 1235 1235 - } 1236 1236 - } else if (rdtgrp->type == RDTMON_GROUP && 1237 1237 - is_mon_groups(parent_kn, rdt_kn_name(kn))) { 1238 1238 - ret = rdtgroup_rmdir_mon(rdtgrp, tmpmask); 1239 1239 - } else { 1240 1240 - ret = -EPERM; 1241 1241 - } 1242 1242 - 1243 1243 - out: 1244 1244 - rdtgroup_kn_unlock(kn); 1245 1245 - free_cpumask_var(tmpmask); 1246 1246 - return ret; 1247 1247 - } 1248 1248 - 1249 1249 - /** 1250 1250 - * mongrp_reparent() - replace parent CTRL_MON group of a MON group 1251 1251 - * @rdtgrp: the MON group whose parent should be replaced 1252 1252 - * @new_prdtgrp: replacement parent CTRL_MON group for @rdtgrp 1253 1253 - * @cpus: cpumask provided by the caller for use during this call 1254 1254 - * 1255 1255 - * Replaces the parent CTRL_MON group for a MON group, resulting in all member 1256 1256 - * tasks' CLOSID immediately changing to that of the new parent group. 1257 1257 - * Monitoring data for the group is unaffected by this operation. 1258 1258 - */ 1259 1259 - static void mongrp_reparent(struct rdtgroup *rdtgrp, 1260 1260 - struct rdtgroup *new_prdtgrp, 1261 1261 - cpumask_var_t cpus) 1262 1262 - { 1263 1263 - struct rdtgroup *prdtgrp = rdtgrp->mon.parent; 1264 1264 - 1265 1265 - WARN_ON(rdtgrp->type != RDTMON_GROUP); 1266 1266 - WARN_ON(new_prdtgrp->type != RDTCTRL_GROUP); 1267 1267 - 1268 1268 - /* Nothing to do when simply renaming a MON group. */ 1269 1269 - if (prdtgrp == new_prdtgrp) 1270 1270 - return; 1271 1271 - 1272 1272 - WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list)); 1273 1273 - list_move_tail(&rdtgrp->mon.crdtgrp_list, 1274 1274 - &new_prdtgrp->mon.crdtgrp_list); 1275 1275 - 1276 1276 - rdtgrp->mon.parent = new_prdtgrp; 1277 1277 - rdtgrp->closid = new_prdtgrp->closid; 1278 1278 - 1279 1279 - /* Propagate updated closid to all tasks in this group. */ 1280 1280 - rdt_move_group_tasks(rdtgrp, rdtgrp, cpus); 1281 1281 - 1282 1282 - update_closid_rmid(cpus, NULL); 1283 1283 - } 1284 1284 - 1285 1285 - static int rdtgroup_rename(struct kernfs_node *kn, 1286 1286 - struct kernfs_node *new_parent, const char *new_name) 1287 1287 - { 1288 1288 - struct kernfs_node *kn_parent; 1289 1289 - struct rdtgroup *new_prdtgrp; 1290 1290 - struct rdtgroup *rdtgrp; 1291 1291 - cpumask_var_t tmpmask; 1292 1292 - int ret; 1293 1293 - 1294 1294 - rdtgrp = kernfs_to_rdtgroup(kn); 1295 1295 - new_prdtgrp = kernfs_to_rdtgroup(new_parent); 1296 1296 - if (!rdtgrp || !new_prdtgrp) 1297 1297 - return -ENOENT; 1298 1298 - 1299 1299 - /* Release both kernfs active_refs before obtaining rdtgroup mutex. */ 1300 1300 - rdtgroup_kn_get(rdtgrp, kn); 1301 1301 - rdtgroup_kn_get(new_prdtgrp, new_parent); 1302 1302 - 1303 1303 - mutex_lock(&rdtgroup_mutex); 1304 1304 - 1305 1305 - rdt_last_cmd_clear(); 1306 1306 - 1307 1307 - /* 1308 1308 - * Don't allow kernfs_to_rdtgroup() to return a parent rdtgroup if 1309 1309 - * either kernfs_node is a file. 1310 1310 - */ 1311 1311 - if (kernfs_type(kn) != KERNFS_DIR || 1312 1312 - kernfs_type(new_parent) != KERNFS_DIR) { 1313 1313 - rdt_last_cmd_puts("Source and destination must be directories"); 1314 1314 - ret = -EPERM; 1315 1315 - goto out; 1316 1316 - } 1317 1317 - 1318 1318 - if ((rdtgrp->flags & RDT_DELETED) || (new_prdtgrp->flags & RDT_DELETED)) { 1319 1319 - ret = -ENOENT; 1320 1320 - goto out; 1321 1321 - } 1322 1322 - 1323 1323 - kn_parent = rdt_kn_parent(kn); 1324 1324 - if (rdtgrp->type != RDTMON_GROUP || !kn_parent || 1325 1325 - !is_mon_groups(kn_parent, rdt_kn_name(kn))) { 1326 1326 - rdt_last_cmd_puts("Source must be a MON group\n"); 1327 1327 - ret = -EPERM; 1328 1328 - goto out; 1329 1329 - } 1330 1330 - 1331 1331 - if (!is_mon_groups(new_parent, new_name)) { 1332 1332 - rdt_last_cmd_puts("Destination must be a mon_groups subdirectory\n"); 1333 1333 - ret = -EPERM; 1334 1334 - goto out; 1335 1335 - } 1336 1336 - 1337 1337 - /* 1338 1338 - * If the MON group is monitoring CPUs, the CPUs must be assigned to the 1339 1339 - * current parent CTRL_MON group and therefore cannot be assigned to 1340 1340 - * the new parent, making the move illegal. 1341 1341 - */ 1342 1342 - if (!cpumask_empty(&rdtgrp->cpu_mask) && 1343 1343 - rdtgrp->mon.parent != new_prdtgrp) { 1344 1344 - rdt_last_cmd_puts("Cannot move a MON group that monitors CPUs\n"); 1345 1345 - ret = -EPERM; 1346 1346 - goto out; 1347 1347 - } 1348 1348 - 1349 1349 - /* 1350 1350 - * Allocate the cpumask for use in mongrp_reparent() to avoid the 1351 1351 - * possibility of failing to allocate it after kernfs_rename() has 1352 1352 - * succeeded. 1353 1353 - */ 1354 1354 - if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) { 1355 1355 - ret = -ENOMEM; 1356 1356 - goto out; 1357 1357 - } 1358 1358 - 1359 1359 - /* 1360 1360 - * Perform all input validation and allocations needed to ensure 1361 1361 - * mongrp_reparent() will succeed before calling kernfs_rename(), 1362 1362 - * otherwise it would be necessary to revert this call if 1363 1363 - * mongrp_reparent() failed. 1364 1364 - */ 1365 1365 - ret = kernfs_rename(kn, new_parent, new_name); 1366 1366 - if (!ret) 1367 1367 - mongrp_reparent(rdtgrp, new_prdtgrp, tmpmask); 1368 1368 - 1369 1369 - free_cpumask_var(tmpmask); 1370 1370 - 1371 1371 - out: 1372 1372 - mutex_unlock(&rdtgroup_mutex); 1373 1373 - rdtgroup_kn_put(rdtgrp, kn); 1374 1374 - rdtgroup_kn_put(new_prdtgrp, new_parent); 1375 1375 - return ret; 1376 1376 - } 1377 1377 - 1378 1378 - static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf) 1379 1379 - { 1380 1380 - if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3)) 1381 1381 - seq_puts(seq, ",cdp"); 1382 1382 - 1383 1383 - if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) 1384 1384 - seq_puts(seq, ",cdpl2"); 1385 1385 - 1386 1386 - if (is_mba_sc(resctrl_arch_get_resource(RDT_RESOURCE_MBA))) 1387 1387 - seq_puts(seq, ",mba_MBps"); 1388 1388 - 1389 1389 - if (resctrl_debug) 1390 1390 - seq_puts(seq, ",debug"); 1391 1391 - 1392 1392 - return 0; 1393 1393 - } 1394 1394 - 1395 1395 - static struct kernfs_syscall_ops rdtgroup_kf_syscall_ops = { 1396 1396 - .mkdir = rdtgroup_mkdir, 1397 1397 - .rmdir = rdtgroup_rmdir, 1398 1398 - .rename = rdtgroup_rename, 1399 1399 - .show_options = rdtgroup_show_options, 1400 1400 - }; 1401 1401 - 1402 1402 - static int rdtgroup_setup_root(struct rdt_fs_context *ctx) 1403 1403 - { 1404 1404 - rdt_root = kernfs_create_root(&rdtgroup_kf_syscall_ops, 1405 1405 - KERNFS_ROOT_CREATE_DEACTIVATED | 1406 1406 - KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK, 1407 1407 - &rdtgroup_default); 1408 1408 - if (IS_ERR(rdt_root)) 1409 1409 - return PTR_ERR(rdt_root); 1410 1410 - 1411 1411 - ctx->kfc.root = rdt_root; 1412 1412 - rdtgroup_default.kn = kernfs_root_to_node(rdt_root); 1413 1413 - 1414 1414 - return 0; 1415 1415 - } 1416 1416 - 1417 1417 - static void rdtgroup_destroy_root(void) 1418 1418 - { 1419 1419 - kernfs_destroy_root(rdt_root); 1420 1420 - rdtgroup_default.kn = NULL; 1421 1421 - } 1422 1422 - 1423 1423 - static void __init rdtgroup_setup_default(void) 1424 1424 - { 1425 1425 - mutex_lock(&rdtgroup_mutex); 1426 1426 - 1427 1427 - rdtgroup_default.closid = RESCTRL_RESERVED_CLOSID; 1428 1428 - rdtgroup_default.mon.rmid = RESCTRL_RESERVED_RMID; 1429 1429 - rdtgroup_default.type = RDTCTRL_GROUP; 1430 1430 - INIT_LIST_HEAD(&rdtgroup_default.mon.crdtgrp_list); 1431 1431 - 1432 1432 - list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups); 1433 1433 - 1434 1434 - mutex_unlock(&rdtgroup_mutex); 1435 1435 - } 1436 1436 - 1437 1437 - static void domain_destroy_mon_state(struct rdt_mon_domain *d) 1438 1438 - { 1439 1439 - bitmap_free(d->rmid_busy_llc); 1440 1440 - kfree(d->mbm_total); 1441 1441 - kfree(d->mbm_local); 1442 1442 - } 1443 1443 - 1444 1444 - void resctrl_offline_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d) 1445 1445 - { 1446 1446 - mutex_lock(&rdtgroup_mutex); 1447 1447 - 1448 1448 - if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) 1449 1449 - mba_sc_domain_destroy(r, d); 1450 1450 - 1451 1451 - mutex_unlock(&rdtgroup_mutex); 1452 1452 - } 1453 1453 - 1454 1454 - void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d) 1455 1455 - { 1456 1456 - mutex_lock(&rdtgroup_mutex); 1457 1457 - 1458 1458 - /* 1459 1459 - * If resctrl is mounted, remove all the 1460 1460 - * per domain monitor data directories. 1461 1461 - */ 1462 1462 - if (resctrl_mounted && resctrl_arch_mon_capable()) 1463 1463 - rmdir_mondata_subdir_allrdtgrp(r, d); 1464 1464 - 1465 1465 - if (resctrl_is_mbm_enabled()) 1466 1466 - cancel_delayed_work(&d->mbm_over); 1467 1467 - if (resctrl_arch_is_llc_occupancy_enabled() && has_busy_rmid(d)) { 1468 1468 - /* 1469 1469 - * When a package is going down, forcefully 1470 1470 - * decrement rmid->ebusy. There is no way to know 1471 1471 - * that the L3 was flushed and hence may lead to 1472 1472 - * incorrect counts in rare scenarios, but leaving 1473 1473 - * the RMID as busy creates RMID leaks if the 1474 1474 - * package never comes back. 1475 1475 - */ 1476 1476 - __check_limbo(d, true); 1477 1477 - cancel_delayed_work(&d->cqm_limbo); 1478 1478 - } 1479 1479 - 1480 1480 - domain_destroy_mon_state(d); 1481 1481 - 1482 1482 - mutex_unlock(&rdtgroup_mutex); 1483 1483 - } 1484 1484 - 1485 1485 - /** 1486 1486 - * domain_setup_mon_state() - Initialise domain monitoring structures. 1487 1487 - * @r: The resource for the newly online domain. 1488 1488 - * @d: The newly online domain. 1489 1489 - * 1490 1490 - * Allocate monitor resources that belong to this domain. 1491 1491 - * Called when the first CPU of a domain comes online, regardless of whether 1492 1492 - * the filesystem is mounted. 1493 1493 - * During boot this may be called before global allocations have been made by 1494 1494 - * resctrl_mon_resource_init(). 1495 1495 - * 1496 1496 - * Returns 0 for success, or -ENOMEM. 1497 1497 - */ 1498 1498 - static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_mon_domain *d) 1499 1499 - { 1500 1500 - u32 idx_limit = resctrl_arch_system_num_rmid_idx(); 1501 1501 - size_t tsize; 1502 1502 - 1503 1503 - if (resctrl_arch_is_llc_occupancy_enabled()) { 1504 1504 - d->rmid_busy_llc = bitmap_zalloc(idx_limit, GFP_KERNEL); 1505 1505 - if (!d->rmid_busy_llc) 1506 1506 - return -ENOMEM; 1507 1507 - } 1508 1508 - if (resctrl_arch_is_mbm_total_enabled()) { 1509 1509 - tsize = sizeof(*d->mbm_total); 1510 1510 - d->mbm_total = kcalloc(idx_limit, tsize, GFP_KERNEL); 1511 1511 - if (!d->mbm_total) { 1512 1512 - bitmap_free(d->rmid_busy_llc); 1513 1513 - return -ENOMEM; 1514 1514 - } 1515 1515 - } 1516 1516 - if (resctrl_arch_is_mbm_local_enabled()) { 1517 1517 - tsize = sizeof(*d->mbm_local); 1518 1518 - d->mbm_local = kcalloc(idx_limit, tsize, GFP_KERNEL); 1519 1519 - if (!d->mbm_local) { 1520 1520 - bitmap_free(d->rmid_busy_llc); 1521 1521 - kfree(d->mbm_total); 1522 1522 - return -ENOMEM; 1523 1523 - } 1524 1524 - } 1525 1525 - 1526 1526 - return 0; 1527 1527 - } 1528 1528 - 1529 1529 - int resctrl_online_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d) 1530 1530 - { 1531 1531 - int err = 0; 1532 1532 - 1533 1533 - mutex_lock(&rdtgroup_mutex); 1534 1534 - 1535 1535 - if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) { 1536 1536 - /* RDT_RESOURCE_MBA is never mon_capable */ 1537 1537 - err = mba_sc_domain_allocate(r, d); 1538 1538 - } 1539 1539 - 1540 1540 - mutex_unlock(&rdtgroup_mutex); 1541 1541 - 1542 1542 - return err; 1543 1543 - } 1544 1544 - 1545 1545 - int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d) 1546 1546 - { 1547 1547 - int err; 1548 1548 - 1549 1549 - mutex_lock(&rdtgroup_mutex); 1550 1550 - 1551 1551 - err = domain_setup_mon_state(r, d); 1552 1552 - if (err) 1553 1553 - goto out_unlock; 1554 1554 - 1555 1555 - if (resctrl_is_mbm_enabled()) { 1556 1556 - INIT_DELAYED_WORK(&d->mbm_over, mbm_handle_overflow); 1557 1557 - mbm_setup_overflow_handler(d, MBM_OVERFLOW_INTERVAL, 1558 1558 - RESCTRL_PICK_ANY_CPU); 1559 1559 - } 1560 1560 - 1561 1561 - if (resctrl_arch_is_llc_occupancy_enabled()) 1562 1562 - INIT_DELAYED_WORK(&d->cqm_limbo, cqm_handle_limbo); 1563 1563 - 1564 1564 - /* 1565 1565 - * If the filesystem is not mounted then only the default resource group 1566 1566 - * exists. Creation of its directories is deferred until mount time 1567 1567 - * by rdt_get_tree() calling mkdir_mondata_all(). 1568 1568 - * If resctrl is mounted, add per domain monitor data directories. 1569 1569 - */ 1570 1570 - if (resctrl_mounted && resctrl_arch_mon_capable()) 1571 1571 - mkdir_mondata_subdir_allrdtgrp(r, d); 1572 1572 - 1573 1573 - out_unlock: 1574 1574 - mutex_unlock(&rdtgroup_mutex); 1575 1575 - 1576 1576 - return err; 1577 1577 - } 1578 1578 - 1579 1579 - void resctrl_online_cpu(unsigned int cpu) 1580 1580 - { 1581 1581 - mutex_lock(&rdtgroup_mutex); 1582 1582 - /* The CPU is set in default rdtgroup after online. */ 1583 1583 - cpumask_set_cpu(cpu, &rdtgroup_default.cpu_mask); 1584 1584 - mutex_unlock(&rdtgroup_mutex); 1585 1585 - } 1586 1586 - 1587 1587 - static void clear_childcpus(struct rdtgroup *r, unsigned int cpu) 1588 1588 - { 1589 1589 - struct rdtgroup *cr; 1590 1590 - 1591 1591 - list_for_each_entry(cr, &r->mon.crdtgrp_list, mon.crdtgrp_list) { 1592 1592 - if (cpumask_test_and_clear_cpu(cpu, &cr->cpu_mask)) 1593 1593 - break; 1594 1594 - } 1595 1595 - } 1596 1596 - 1597 1597 - static struct rdt_mon_domain *get_mon_domain_from_cpu(int cpu, 1598 1598 - struct rdt_resource *r) 1599 1599 - { 1600 1600 - struct rdt_mon_domain *d; 1601 1601 - 1602 1602 - lockdep_assert_cpus_held(); 1603 1603 - 1604 1604 - list_for_each_entry(d, &r->mon_domains, hdr.list) { 1605 1605 - /* Find the domain that contains this CPU */ 1606 1606 - if (cpumask_test_cpu(cpu, &d->hdr.cpu_mask)) 1607 1607 - return d; 1608 1608 - } 1609 1609 - 1610 1610 - return NULL; 1611 1611 - } 1612 1612 - 1613 1613 - void resctrl_offline_cpu(unsigned int cpu) 1614 1614 - { 1615 1615 - struct rdt_resource *l3 = resctrl_arch_get_resource(RDT_RESOURCE_L3); 1616 1616 - struct rdt_mon_domain *d; 1617 1617 - struct rdtgroup *rdtgrp; 1618 1618 - 1619 1619 - mutex_lock(&rdtgroup_mutex); 1620 1620 - list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 1621 1621 - if (cpumask_test_and_clear_cpu(cpu, &rdtgrp->cpu_mask)) { 1622 1622 - clear_childcpus(rdtgrp, cpu); 1623 1623 - break; 1624 1624 - } 1625 1625 - } 1626 1626 - 1627 1627 - if (!l3->mon_capable) 1628 1628 - goto out_unlock; 1629 1629 - 1630 1630 - d = get_mon_domain_from_cpu(cpu, l3); 1631 1631 - if (d) { 1632 1632 - if (resctrl_is_mbm_enabled() && cpu == d->mbm_work_cpu) { 1633 1633 - cancel_delayed_work(&d->mbm_over); 1634 1634 - mbm_setup_overflow_handler(d, 0, cpu); 1635 1635 - } 1636 1636 - if (resctrl_arch_is_llc_occupancy_enabled() && 1637 1637 - cpu == d->cqm_work_cpu && has_busy_rmid(d)) { 1638 1638 - cancel_delayed_work(&d->cqm_limbo); 1639 1639 - cqm_setup_limbo_handler(d, 0, cpu); 1640 1640 - } 1641 1641 - } 1642 1642 - 1643 1643 - out_unlock: 1644 1644 - mutex_unlock(&rdtgroup_mutex); 1645 1645 - } 1646 1646 - 1647 1647 - /* 1648 1648 - * resctrl_init - resctrl filesystem initialization 1649 1649 - * 1650 1650 - * Setup resctrl file system including set up root, create mount point, 1651 1651 - * register resctrl filesystem, and initialize files under root directory. 1652 1652 - * 1653 1653 - * Return: 0 on success or -errno 1654 1654 - */ 1655 1655 - int __init resctrl_init(void) 1656 1656 - { 1657 1657 - int ret = 0; 1658 1658 - 1659 1659 - seq_buf_init(&last_cmd_status, last_cmd_status_buf, 1660 1660 - sizeof(last_cmd_status_buf)); 1661 1661 - 1662 1662 - rdtgroup_setup_default(); 1663 1663 - 1664 1664 - thread_throttle_mode_init(); 1665 1665 - 1666 1666 - ret = resctrl_mon_resource_init(); 1667 1667 - if (ret) 1668 1668 - return ret; 1669 1669 - 1670 1670 - ret = sysfs_create_mount_point(fs_kobj, "resctrl"); 1671 1671 - if (ret) { 1672 1672 - resctrl_mon_resource_exit(); 1673 1673 - return ret; 1674 1674 - } 1675 1675 - 1676 1676 - ret = register_filesystem(&rdt_fs_type); 1677 1677 - if (ret) 1678 1678 - goto cleanup_mountpoint; 1679 1679 - 1680 1680 - /* 1681 1681 - * Adding the resctrl debugfs directory here may not be ideal since 1682 1682 - * it would let the resctrl debugfs directory appear on the debugfs 1683 1683 - * filesystem before the resctrl filesystem is mounted. 1684 1684 - * It may also be ok since that would enable debugging of RDT before 1685 1685 - * resctrl is mounted. 1686 1686 - * The reason why the debugfs directory is created here and not in 1687 1687 - * rdt_get_tree() is because rdt_get_tree() takes rdtgroup_mutex and 1688 1688 - * during the debugfs directory creation also &sb->s_type->i_mutex_key 1689 1689 - * (the lockdep class of inode->i_rwsem). Other filesystem 1690 1690 - * interactions (eg. SyS_getdents) have the lock ordering: 1691 1691 - * &sb->s_type->i_mutex_key --> &mm->mmap_lock 1692 1692 - * During mmap(), called with &mm->mmap_lock, the rdtgroup_mutex 1693 1693 - * is taken, thus creating dependency: 1694 1694 - * &mm->mmap_lock --> rdtgroup_mutex for the latter that can cause 1695 1695 - * issues considering the other two lock dependencies. 1696 1696 - * By creating the debugfs directory here we avoid a dependency 1697 1697 - * that may cause deadlock (even though file operations cannot 1698 1698 - * occur until the filesystem is mounted, but I do not know how to 1699 1699 - * tell lockdep that). 1700 1700 - */ 1701 1701 - debugfs_resctrl = debugfs_create_dir("resctrl", NULL); 1702 1702 - 1703 1703 - return 0; 1704 1704 - 1705 1705 - cleanup_mountpoint: 1706 1706 - sysfs_remove_mount_point(fs_kobj, "resctrl"); 1707 1707 - resctrl_mon_resource_exit(); 1708 1708 - 1709 1709 - return ret; 1710 1710 - } 1711 1711 - 1712 1712 - void __exit resctrl_exit(void) 1713 1713 - { 1714 1714 - debugfs_remove_recursive(debugfs_resctrl); 1715 1715 - unregister_filesystem(&rdt_fs_type); 1716 1716 - sysfs_remove_mount_point(fs_kobj, "resctrl"); 1717 1717 - 1718 1718 - resctrl_mon_resource_exit(); 1719 2955 }

+6 -20

arch/x86/kernel/cpu/resctrl/trace.h arch/x86/kernel/cpu/resctrl/pseudo_lock_trace.h

reviewed

··· 2 2 #undef TRACE_SYSTEM 3 3 #define TRACE_SYSTEM resctrl 4 4 5 5 - #if !defined(_TRACE_RESCTRL_H) || defined(TRACE_HEADER_MULTI_READ) 6 6 - #define _TRACE_RESCTRL_H 5 5 + #if !defined(_X86_RESCTRL_PSEUDO_LOCK_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) 6 6 + #define _X86_RESCTRL_PSEUDO_LOCK_TRACE_H 7 7 8 8 #include <linux/tracepoint.h> 9 9 ··· 35 35 TP_printk("hits=%llu miss=%llu", 36 36 __entry->l3_hits, __entry->l3_miss)); 37 37 38 38 - TRACE_EVENT(mon_llc_occupancy_limbo, 39 39 - TP_PROTO(u32 ctrl_hw_id, u32 mon_hw_id, int domain_id, u64 llc_occupancy_bytes), 40 40 - TP_ARGS(ctrl_hw_id, mon_hw_id, domain_id, llc_occupancy_bytes), 41 41 - TP_STRUCT__entry(__field(u32, ctrl_hw_id) 42 42 - __field(u32, mon_hw_id) 43 43 - __field(int, domain_id) 44 44 - __field(u64, llc_occupancy_bytes)), 45 45 - TP_fast_assign(__entry->ctrl_hw_id = ctrl_hw_id; 46 46 - __entry->mon_hw_id = mon_hw_id; 47 47 - __entry->domain_id = domain_id; 48 48 - __entry->llc_occupancy_bytes = llc_occupancy_bytes;), 49 49 - TP_printk("ctrl_hw_id=%u mon_hw_id=%u domain_id=%d llc_occupancy_bytes=%llu", 50 50 - __entry->ctrl_hw_id, __entry->mon_hw_id, __entry->domain_id, 51 51 - __entry->llc_occupancy_bytes) 52 52 - ); 53 53 - 54 54 - #endif /* _TRACE_RESCTRL_H */ 38 38 + #endif /* _X86_RESCTRL_PSEUDO_LOCK_TRACE_H */ 55 39 56 40 #undef TRACE_INCLUDE_PATH 57 41 #define TRACE_INCLUDE_PATH . 58 58 - #define TRACE_INCLUDE_FILE trace 42 42 + 43 43 + #define TRACE_INCLUDE_FILE pseudo_lock_trace 44 44 + 59 45 #include <trace/define_trace.h>

+1 -1

arch/x86/kernel/process_32.c

reviewed

··· 208 208 raw_cpu_write(current_task, next_p); 209 209 210 210 /* Load the Intel cache allocation PQR MSR. */ 211 211 - resctrl_sched_in(next_p); 211 211 + resctrl_arch_sched_in(next_p); 212 212 213 213 return prev_p; 214 214 }

+1 -1

arch/x86/kernel/process_64.c

reviewed

··· 705 705 } 706 706 707 707 /* Load the Intel cache allocation PQR MSR. */ 708 708 - resctrl_sched_in(next_p); 708 708 + resctrl_arch_sched_in(next_p); 709 709 710 710 return prev_p; 711 711 }

+1

fs/Kconfig

reviewed

··· 335 335 source "fs/hpfs/Kconfig" 336 336 source "fs/qnx4/Kconfig" 337 337 source "fs/qnx6/Kconfig" 338 338 + source "fs/resctrl/Kconfig" 338 339 source "fs/romfs/Kconfig" 339 340 source "fs/pstore/Kconfig" 340 341 source "fs/ufs/Kconfig"

+1

fs/Makefile

reviewed

··· 128 128 obj-$(CONFIG_VBOXSF_FS) += vboxsf/ 129 129 obj-$(CONFIG_ZONEFS_FS) += zonefs/ 130 130 obj-$(CONFIG_BPF_LSM) += bpf_fs_kfuncs.o 131 131 + obj-$(CONFIG_RESCTRL_FS) += resctrl/

+39

fs/resctrl/Kconfig

reviewed

··· 1 1 + config RESCTRL_FS 2 2 + bool "CPU Resource Control Filesystem (resctrl)" 3 3 + depends on ARCH_HAS_CPU_RESCTRL 4 4 + select KERNFS 5 5 + select PROC_CPU_RESCTRL if PROC_FS 6 6 + help 7 7 + Some architectures provide hardware facilities to group tasks and 8 8 + monitor and control their usage of memory system resources such as 9 9 + caches and memory bandwidth. Examples of such facilities include 10 10 + Intel's Resource Director Technology (Intel(R) RDT) and AMD's 11 11 + Platform Quality of Service (AMD QoS). 12 12 + 13 13 + If your system has the necessary support and you want to be able to 14 14 + assign tasks to groups and manipulate the associated resource 15 15 + monitors and controls from userspace, say Y here to get a mountable 16 16 + 'resctrl' filesystem that lets you do just that. 17 17 + 18 18 + If nothing mounts or prods the 'resctrl' filesystem, resource 19 19 + controls and monitors are left in a quiescent, permissive state. 20 20 + 21 21 + On architectures where this can be disabled independently, it is 22 22 + safe to say N. 23 23 + 24 24 + See <file:Documentation/filesystems/resctrl.rst> for more information. 25 25 + 26 26 + config RESCTRL_FS_PSEUDO_LOCK 27 27 + bool 28 28 + depends on RESCTRL_FS 29 29 + help 30 30 + Software mechanism to pin data in a cache portion using 31 31 + micro-architecture specific knowledge. 32 32 + 33 33 + config RESCTRL_RMID_DEPENDS_ON_CLOSID 34 34 + bool 35 35 + depends on RESCTRL_FS 36 36 + help 37 37 + Enabled by the architecture when the RMID values depend on the CLOSID. 38 38 + This causes the CLOSID allocator to search for CLOSID with clean 39 39 + RMID.

+6

fs/resctrl/Makefile

reviewed

··· 1 1 + # SPDX-License-Identifier: GPL-2.0 2 2 + obj-$(CONFIG_RESCTRL_FS) += rdtgroup.o ctrlmondata.o monitor.o 3 3 + obj-$(CONFIG_RESCTRL_FS_PSEUDO_LOCK) += pseudo_lock.o 4 4 + 5 5 + # To allow define_trace.h's recursive include: 6 6 + CFLAGS_monitor.o = -I$(src)

+661

fs/resctrl/ctrlmondata.c

reviewed

··· 1 1 + // SPDX-License-Identifier: GPL-2.0-only 2 2 + /* 3 3 + * Resource Director Technology(RDT) 4 4 + * - Cache Allocation code. 5 5 + * 6 6 + * Copyright (C) 2016 Intel Corporation 7 7 + * 8 8 + * Authors: 9 9 + * Fenghua Yu <fenghua.yu@intel.com> 10 10 + * Tony Luck <tony.luck@intel.com> 11 11 + * 12 12 + * More information about RDT be found in the Intel (R) x86 Architecture 13 13 + * Software Developer Manual June 2016, volume 3, section 17.17. 14 14 + */ 15 15 + 16 16 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 17 17 + 18 18 + #include <linux/cpu.h> 19 19 + #include <linux/kernfs.h> 20 20 + #include <linux/seq_file.h> 21 21 + #include <linux/slab.h> 22 22 + #include <linux/tick.h> 23 23 + 24 24 + #include "internal.h" 25 25 + 26 26 + struct rdt_parse_data { 27 27 + struct rdtgroup *rdtgrp; 28 28 + char *buf; 29 29 + }; 30 30 + 31 31 + typedef int (ctrlval_parser_t)(struct rdt_parse_data *data, 32 32 + struct resctrl_schema *s, 33 33 + struct rdt_ctrl_domain *d); 34 34 + 35 35 + /* 36 36 + * Check whether MBA bandwidth percentage value is correct. The value is 37 37 + * checked against the minimum and max bandwidth values specified by the 38 38 + * hardware. The allocated bandwidth percentage is rounded to the next 39 39 + * control step available on the hardware. 40 40 + */ 41 41 + static bool bw_validate(char *buf, u32 *data, struct rdt_resource *r) 42 42 + { 43 43 + int ret; 44 44 + u32 bw; 45 45 + 46 46 + /* 47 47 + * Only linear delay values is supported for current Intel SKUs. 48 48 + */ 49 49 + if (!r->membw.delay_linear && r->membw.arch_needs_linear) { 50 50 + rdt_last_cmd_puts("No support for non-linear MB domains\n"); 51 51 + return false; 52 52 + } 53 53 + 54 54 + ret = kstrtou32(buf, 10, &bw); 55 55 + if (ret) { 56 56 + rdt_last_cmd_printf("Invalid MB value %s\n", buf); 57 57 + return false; 58 58 + } 59 59 + 60 60 + /* Nothing else to do if software controller is enabled. */ 61 61 + if (is_mba_sc(r)) { 62 62 + *data = bw; 63 63 + return true; 64 64 + } 65 65 + 66 66 + if (bw < r->membw.min_bw || bw > r->membw.max_bw) { 67 67 + rdt_last_cmd_printf("MB value %u out of range [%d,%d]\n", 68 68 + bw, r->membw.min_bw, r->membw.max_bw); 69 69 + return false; 70 70 + } 71 71 + 72 72 + *data = roundup(bw, (unsigned long)r->membw.bw_gran); 73 73 + return true; 74 74 + } 75 75 + 76 76 + static int parse_bw(struct rdt_parse_data *data, struct resctrl_schema *s, 77 77 + struct rdt_ctrl_domain *d) 78 78 + { 79 79 + struct resctrl_staged_config *cfg; 80 80 + u32 closid = data->rdtgrp->closid; 81 81 + struct rdt_resource *r = s->res; 82 82 + u32 bw_val; 83 83 + 84 84 + cfg = &d->staged_config[s->conf_type]; 85 85 + if (cfg->have_new_ctrl) { 86 86 + rdt_last_cmd_printf("Duplicate domain %d\n", d->hdr.id); 87 87 + return -EINVAL; 88 88 + } 89 89 + 90 90 + if (!bw_validate(data->buf, &bw_val, r)) 91 91 + return -EINVAL; 92 92 + 93 93 + if (is_mba_sc(r)) { 94 94 + d->mbps_val[closid] = bw_val; 95 95 + return 0; 96 96 + } 97 97 + 98 98 + cfg->new_ctrl = bw_val; 99 99 + cfg->have_new_ctrl = true; 100 100 + 101 101 + return 0; 102 102 + } 103 103 + 104 104 + /* 105 105 + * Check whether a cache bit mask is valid. 106 106 + * On Intel CPUs, non-contiguous 1s value support is indicated by CPUID: 107 107 + * - CPUID.0x10.1:ECX[3]: L3 non-contiguous 1s value supported if 1 108 108 + * - CPUID.0x10.2:ECX[3]: L2 non-contiguous 1s value supported if 1 109 109 + * 110 110 + * Haswell does not support a non-contiguous 1s value and additionally 111 111 + * requires at least two bits set. 112 112 + * AMD allows non-contiguous bitmasks. 113 113 + */ 114 114 + static bool cbm_validate(char *buf, u32 *data, struct rdt_resource *r) 115 115 + { 116 116 + u32 supported_bits = BIT_MASK(r->cache.cbm_len) - 1; 117 117 + unsigned int cbm_len = r->cache.cbm_len; 118 118 + unsigned long first_bit, zero_bit, val; 119 119 + int ret; 120 120 + 121 121 + ret = kstrtoul(buf, 16, &val); 122 122 + if (ret) { 123 123 + rdt_last_cmd_printf("Non-hex character in the mask %s\n", buf); 124 124 + return false; 125 125 + } 126 126 + 127 127 + if ((r->cache.min_cbm_bits > 0 && val == 0) || val > supported_bits) { 128 128 + rdt_last_cmd_puts("Mask out of range\n"); 129 129 + return false; 130 130 + } 131 131 + 132 132 + first_bit = find_first_bit(&val, cbm_len); 133 133 + zero_bit = find_next_zero_bit(&val, cbm_len, first_bit); 134 134 + 135 135 + /* Are non-contiguous bitmasks allowed? */ 136 136 + if (!r->cache.arch_has_sparse_bitmasks && 137 137 + (find_next_bit(&val, cbm_len, zero_bit) < cbm_len)) { 138 138 + rdt_last_cmd_printf("The mask %lx has non-consecutive 1-bits\n", val); 139 139 + return false; 140 140 + } 141 141 + 142 142 + if ((zero_bit - first_bit) < r->cache.min_cbm_bits) { 143 143 + rdt_last_cmd_printf("Need at least %d bits in the mask\n", 144 144 + r->cache.min_cbm_bits); 145 145 + return false; 146 146 + } 147 147 + 148 148 + *data = val; 149 149 + return true; 150 150 + } 151 151 + 152 152 + /* 153 153 + * Read one cache bit mask (hex). Check that it is valid for the current 154 154 + * resource type. 155 155 + */ 156 156 + static int parse_cbm(struct rdt_parse_data *data, struct resctrl_schema *s, 157 157 + struct rdt_ctrl_domain *d) 158 158 + { 159 159 + struct rdtgroup *rdtgrp = data->rdtgrp; 160 160 + struct resctrl_staged_config *cfg; 161 161 + struct rdt_resource *r = s->res; 162 162 + u32 cbm_val; 163 163 + 164 164 + cfg = &d->staged_config[s->conf_type]; 165 165 + if (cfg->have_new_ctrl) { 166 166 + rdt_last_cmd_printf("Duplicate domain %d\n", d->hdr.id); 167 167 + return -EINVAL; 168 168 + } 169 169 + 170 170 + /* 171 171 + * Cannot set up more than one pseudo-locked region in a cache 172 172 + * hierarchy. 173 173 + */ 174 174 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP && 175 175 + rdtgroup_pseudo_locked_in_hierarchy(d)) { 176 176 + rdt_last_cmd_puts("Pseudo-locked region in hierarchy\n"); 177 177 + return -EINVAL; 178 178 + } 179 179 + 180 180 + if (!cbm_validate(data->buf, &cbm_val, r)) 181 181 + return -EINVAL; 182 182 + 183 183 + if ((rdtgrp->mode == RDT_MODE_EXCLUSIVE || 184 184 + rdtgrp->mode == RDT_MODE_SHAREABLE) && 185 185 + rdtgroup_cbm_overlaps_pseudo_locked(d, cbm_val)) { 186 186 + rdt_last_cmd_puts("CBM overlaps with pseudo-locked region\n"); 187 187 + return -EINVAL; 188 188 + } 189 189 + 190 190 + /* 191 191 + * The CBM may not overlap with the CBM of another closid if 192 192 + * either is exclusive. 193 193 + */ 194 194 + if (rdtgroup_cbm_overlaps(s, d, cbm_val, rdtgrp->closid, true)) { 195 195 + rdt_last_cmd_puts("Overlaps with exclusive group\n"); 196 196 + return -EINVAL; 197 197 + } 198 198 + 199 199 + if (rdtgroup_cbm_overlaps(s, d, cbm_val, rdtgrp->closid, false)) { 200 200 + if (rdtgrp->mode == RDT_MODE_EXCLUSIVE || 201 201 + rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 202 202 + rdt_last_cmd_puts("Overlaps with other group\n"); 203 203 + return -EINVAL; 204 204 + } 205 205 + } 206 206 + 207 207 + cfg->new_ctrl = cbm_val; 208 208 + cfg->have_new_ctrl = true; 209 209 + 210 210 + return 0; 211 211 + } 212 212 + 213 213 + /* 214 214 + * For each domain in this resource we expect to find a series of: 215 215 + * id=mask 216 216 + * separated by ";". The "id" is in decimal, and must match one of 217 217 + * the "id"s for this resource. 218 218 + */ 219 219 + static int parse_line(char *line, struct resctrl_schema *s, 220 220 + struct rdtgroup *rdtgrp) 221 221 + { 222 222 + enum resctrl_conf_type t = s->conf_type; 223 223 + ctrlval_parser_t *parse_ctrlval = NULL; 224 224 + struct resctrl_staged_config *cfg; 225 225 + struct rdt_resource *r = s->res; 226 226 + struct rdt_parse_data data; 227 227 + struct rdt_ctrl_domain *d; 228 228 + char *dom = NULL, *id; 229 229 + unsigned long dom_id; 230 230 + 231 231 + /* Walking r->domains, ensure it can't race with cpuhp */ 232 232 + lockdep_assert_cpus_held(); 233 233 + 234 234 + switch (r->schema_fmt) { 235 235 + case RESCTRL_SCHEMA_BITMAP: 236 236 + parse_ctrlval = &parse_cbm; 237 237 + break; 238 238 + case RESCTRL_SCHEMA_RANGE: 239 239 + parse_ctrlval = &parse_bw; 240 240 + break; 241 241 + } 242 242 + 243 243 + if (WARN_ON_ONCE(!parse_ctrlval)) 244 244 + return -EINVAL; 245 245 + 246 246 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP && 247 247 + (r->rid == RDT_RESOURCE_MBA || r->rid == RDT_RESOURCE_SMBA)) { 248 248 + rdt_last_cmd_puts("Cannot pseudo-lock MBA resource\n"); 249 249 + return -EINVAL; 250 250 + } 251 251 + 252 252 + next: 253 253 + if (!line || line[0] == '\0') 254 254 + return 0; 255 255 + dom = strsep(&line, ";"); 256 256 + id = strsep(&dom, "="); 257 257 + if (!dom || kstrtoul(id, 10, &dom_id)) { 258 258 + rdt_last_cmd_puts("Missing '=' or non-numeric domain\n"); 259 259 + return -EINVAL; 260 260 + } 261 261 + dom = strim(dom); 262 262 + list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 263 263 + if (d->hdr.id == dom_id) { 264 264 + data.buf = dom; 265 265 + data.rdtgrp = rdtgrp; 266 266 + if (parse_ctrlval(&data, s, d)) 267 267 + return -EINVAL; 268 268 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 269 269 + cfg = &d->staged_config[t]; 270 270 + /* 271 271 + * In pseudo-locking setup mode and just 272 272 + * parsed a valid CBM that should be 273 273 + * pseudo-locked. Only one locked region per 274 274 + * resource group and domain so just do 275 275 + * the required initialization for single 276 276 + * region and return. 277 277 + */ 278 278 + rdtgrp->plr->s = s; 279 279 + rdtgrp->plr->d = d; 280 280 + rdtgrp->plr->cbm = cfg->new_ctrl; 281 281 + d->plr = rdtgrp->plr; 282 282 + return 0; 283 283 + } 284 284 + goto next; 285 285 + } 286 286 + } 287 287 + return -EINVAL; 288 288 + } 289 289 + 290 290 + static int rdtgroup_parse_resource(char *resname, char *tok, 291 291 + struct rdtgroup *rdtgrp) 292 292 + { 293 293 + struct resctrl_schema *s; 294 294 + 295 295 + list_for_each_entry(s, &resctrl_schema_all, list) { 296 296 + if (!strcmp(resname, s->name) && rdtgrp->closid < s->num_closid) 297 297 + return parse_line(tok, s, rdtgrp); 298 298 + } 299 299 + rdt_last_cmd_printf("Unknown or unsupported resource name '%s'\n", resname); 300 300 + return -EINVAL; 301 301 + } 302 302 + 303 303 + ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of, 304 304 + char *buf, size_t nbytes, loff_t off) 305 305 + { 306 306 + struct resctrl_schema *s; 307 307 + struct rdtgroup *rdtgrp; 308 308 + struct rdt_resource *r; 309 309 + char *tok, *resname; 310 310 + int ret = 0; 311 311 + 312 312 + /* Valid input requires a trailing newline */ 313 313 + if (nbytes == 0 || buf[nbytes - 1] != '\n') 314 314 + return -EINVAL; 315 315 + buf[nbytes - 1] = '\0'; 316 316 + 317 317 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 318 318 + if (!rdtgrp) { 319 319 + rdtgroup_kn_unlock(of->kn); 320 320 + return -ENOENT; 321 321 + } 322 322 + rdt_last_cmd_clear(); 323 323 + 324 324 + /* 325 325 + * No changes to pseudo-locked region allowed. It has to be removed 326 326 + * and re-created instead. 327 327 + */ 328 328 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 329 329 + ret = -EINVAL; 330 330 + rdt_last_cmd_puts("Resource group is pseudo-locked\n"); 331 331 + goto out; 332 332 + } 333 333 + 334 334 + rdt_staged_configs_clear(); 335 335 + 336 336 + while ((tok = strsep(&buf, "\n")) != NULL) { 337 337 + resname = strim(strsep(&tok, ":")); 338 338 + if (!tok) { 339 339 + rdt_last_cmd_puts("Missing ':'\n"); 340 340 + ret = -EINVAL; 341 341 + goto out; 342 342 + } 343 343 + if (tok[0] == '\0') { 344 344 + rdt_last_cmd_printf("Missing '%s' value\n", resname); 345 345 + ret = -EINVAL; 346 346 + goto out; 347 347 + } 348 348 + ret = rdtgroup_parse_resource(resname, tok, rdtgrp); 349 349 + if (ret) 350 350 + goto out; 351 351 + } 352 352 + 353 353 + list_for_each_entry(s, &resctrl_schema_all, list) { 354 354 + r = s->res; 355 355 + 356 356 + /* 357 357 + * Writes to mba_sc resources update the software controller, 358 358 + * not the control MSR. 359 359 + */ 360 360 + if (is_mba_sc(r)) 361 361 + continue; 362 362 + 363 363 + ret = resctrl_arch_update_domains(r, rdtgrp->closid); 364 364 + if (ret) 365 365 + goto out; 366 366 + } 367 367 + 368 368 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 369 369 + /* 370 370 + * If pseudo-locking fails we keep the resource group in 371 371 + * mode RDT_MODE_PSEUDO_LOCKSETUP with its class of service 372 372 + * active and updated for just the domain the pseudo-locked 373 373 + * region was requested for. 374 374 + */ 375 375 + ret = rdtgroup_pseudo_lock_create(rdtgrp); 376 376 + } 377 377 + 378 378 + out: 379 379 + rdt_staged_configs_clear(); 380 380 + rdtgroup_kn_unlock(of->kn); 381 381 + return ret ?: nbytes; 382 382 + } 383 383 + 384 384 + static void show_doms(struct seq_file *s, struct resctrl_schema *schema, int closid) 385 385 + { 386 386 + struct rdt_resource *r = schema->res; 387 387 + struct rdt_ctrl_domain *dom; 388 388 + bool sep = false; 389 389 + u32 ctrl_val; 390 390 + 391 391 + /* Walking r->domains, ensure it can't race with cpuhp */ 392 392 + lockdep_assert_cpus_held(); 393 393 + 394 394 + seq_printf(s, "%*s:", max_name_width, schema->name); 395 395 + list_for_each_entry(dom, &r->ctrl_domains, hdr.list) { 396 396 + if (sep) 397 397 + seq_puts(s, ";"); 398 398 + 399 399 + if (is_mba_sc(r)) 400 400 + ctrl_val = dom->mbps_val[closid]; 401 401 + else 402 402 + ctrl_val = resctrl_arch_get_config(r, dom, closid, 403 403 + schema->conf_type); 404 404 + 405 405 + seq_printf(s, schema->fmt_str, dom->hdr.id, ctrl_val); 406 406 + sep = true; 407 407 + } 408 408 + seq_puts(s, "\n"); 409 409 + } 410 410 + 411 411 + int rdtgroup_schemata_show(struct kernfs_open_file *of, 412 412 + struct seq_file *s, void *v) 413 413 + { 414 414 + struct resctrl_schema *schema; 415 415 + struct rdtgroup *rdtgrp; 416 416 + int ret = 0; 417 417 + u32 closid; 418 418 + 419 419 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 420 420 + if (rdtgrp) { 421 421 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 422 422 + list_for_each_entry(schema, &resctrl_schema_all, list) { 423 423 + seq_printf(s, "%s:uninitialized\n", schema->name); 424 424 + } 425 425 + } else if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 426 426 + if (!rdtgrp->plr->d) { 427 427 + rdt_last_cmd_clear(); 428 428 + rdt_last_cmd_puts("Cache domain offline\n"); 429 429 + ret = -ENODEV; 430 430 + } else { 431 431 + seq_printf(s, "%s:%d=%x\n", 432 432 + rdtgrp->plr->s->res->name, 433 433 + rdtgrp->plr->d->hdr.id, 434 434 + rdtgrp->plr->cbm); 435 435 + } 436 436 + } else { 437 437 + closid = rdtgrp->closid; 438 438 + list_for_each_entry(schema, &resctrl_schema_all, list) { 439 439 + if (closid < schema->num_closid) 440 440 + show_doms(s, schema, closid); 441 441 + } 442 442 + } 443 443 + } else { 444 444 + ret = -ENOENT; 445 445 + } 446 446 + rdtgroup_kn_unlock(of->kn); 447 447 + return ret; 448 448 + } 449 449 + 450 450 + static int smp_mon_event_count(void *arg) 451 451 + { 452 452 + mon_event_count(arg); 453 453 + 454 454 + return 0; 455 455 + } 456 456 + 457 457 + ssize_t rdtgroup_mba_mbps_event_write(struct kernfs_open_file *of, 458 458 + char *buf, size_t nbytes, loff_t off) 459 459 + { 460 460 + struct rdtgroup *rdtgrp; 461 461 + int ret = 0; 462 462 + 463 463 + /* Valid input requires a trailing newline */ 464 464 + if (nbytes == 0 || buf[nbytes - 1] != '\n') 465 465 + return -EINVAL; 466 466 + buf[nbytes - 1] = '\0'; 467 467 + 468 468 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 469 469 + if (!rdtgrp) { 470 470 + rdtgroup_kn_unlock(of->kn); 471 471 + return -ENOENT; 472 472 + } 473 473 + rdt_last_cmd_clear(); 474 474 + 475 475 + if (!strcmp(buf, "mbm_local_bytes")) { 476 476 + if (resctrl_arch_is_mbm_local_enabled()) 477 477 + rdtgrp->mba_mbps_event = QOS_L3_MBM_LOCAL_EVENT_ID; 478 478 + else 479 479 + ret = -EINVAL; 480 480 + } else if (!strcmp(buf, "mbm_total_bytes")) { 481 481 + if (resctrl_arch_is_mbm_total_enabled()) 482 482 + rdtgrp->mba_mbps_event = QOS_L3_MBM_TOTAL_EVENT_ID; 483 483 + else 484 484 + ret = -EINVAL; 485 485 + } else { 486 486 + ret = -EINVAL; 487 487 + } 488 488 + 489 489 + if (ret) 490 490 + rdt_last_cmd_printf("Unsupported event id '%s'\n", buf); 491 491 + 492 492 + rdtgroup_kn_unlock(of->kn); 493 493 + 494 494 + return ret ?: nbytes; 495 495 + } 496 496 + 497 497 + int rdtgroup_mba_mbps_event_show(struct kernfs_open_file *of, 498 498 + struct seq_file *s, void *v) 499 499 + { 500 500 + struct rdtgroup *rdtgrp; 501 501 + int ret = 0; 502 502 + 503 503 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 504 504 + 505 505 + if (rdtgrp) { 506 506 + switch (rdtgrp->mba_mbps_event) { 507 507 + case QOS_L3_MBM_LOCAL_EVENT_ID: 508 508 + seq_puts(s, "mbm_local_bytes\n"); 509 509 + break; 510 510 + case QOS_L3_MBM_TOTAL_EVENT_ID: 511 511 + seq_puts(s, "mbm_total_bytes\n"); 512 512 + break; 513 513 + default: 514 514 + pr_warn_once("Bad event %d\n", rdtgrp->mba_mbps_event); 515 515 + ret = -EINVAL; 516 516 + break; 517 517 + } 518 518 + } else { 519 519 + ret = -ENOENT; 520 520 + } 521 521 + 522 522 + rdtgroup_kn_unlock(of->kn); 523 523 + 524 524 + return ret; 525 525 + } 526 526 + 527 527 + struct rdt_domain_hdr *resctrl_find_domain(struct list_head *h, int id, 528 528 + struct list_head **pos) 529 529 + { 530 530 + struct rdt_domain_hdr *d; 531 531 + struct list_head *l; 532 532 + 533 533 + list_for_each(l, h) { 534 534 + d = list_entry(l, struct rdt_domain_hdr, list); 535 535 + /* When id is found, return its domain. */ 536 536 + if (id == d->id) 537 537 + return d; 538 538 + /* Stop searching when finding id's position in sorted list. */ 539 539 + if (id < d->id) 540 540 + break; 541 541 + } 542 542 + 543 543 + if (pos) 544 544 + *pos = l; 545 545 + 546 546 + return NULL; 547 547 + } 548 548 + 549 549 + void mon_event_read(struct rmid_read *rr, struct rdt_resource *r, 550 550 + struct rdt_mon_domain *d, struct rdtgroup *rdtgrp, 551 551 + cpumask_t *cpumask, int evtid, int first) 552 552 + { 553 553 + int cpu; 554 554 + 555 555 + /* When picking a CPU from cpu_mask, ensure it can't race with cpuhp */ 556 556 + lockdep_assert_cpus_held(); 557 557 + 558 558 + /* 559 559 + * Setup the parameters to pass to mon_event_count() to read the data. 560 560 + */ 561 561 + rr->rgrp = rdtgrp; 562 562 + rr->evtid = evtid; 563 563 + rr->r = r; 564 564 + rr->d = d; 565 565 + rr->first = first; 566 566 + rr->arch_mon_ctx = resctrl_arch_mon_ctx_alloc(r, evtid); 567 567 + if (IS_ERR(rr->arch_mon_ctx)) { 568 568 + rr->err = -EINVAL; 569 569 + return; 570 570 + } 571 571 + 572 572 + cpu = cpumask_any_housekeeping(cpumask, RESCTRL_PICK_ANY_CPU); 573 573 + 574 574 + /* 575 575 + * cpumask_any_housekeeping() prefers housekeeping CPUs, but 576 576 + * are all the CPUs nohz_full? If yes, pick a CPU to IPI. 577 577 + * MPAM's resctrl_arch_rmid_read() is unable to read the 578 578 + * counters on some platforms if its called in IRQ context. 579 579 + */ 580 580 + if (tick_nohz_full_cpu(cpu)) 581 581 + smp_call_function_any(cpumask, mon_event_count, rr, 1); 582 582 + else 583 583 + smp_call_on_cpu(cpu, smp_mon_event_count, rr, false); 584 584 + 585 585 + resctrl_arch_mon_ctx_free(r, evtid, rr->arch_mon_ctx); 586 586 + } 587 587 + 588 588 + int rdtgroup_mondata_show(struct seq_file *m, void *arg) 589 589 + { 590 590 + struct kernfs_open_file *of = m->private; 591 591 + enum resctrl_res_level resid; 592 592 + enum resctrl_event_id evtid; 593 593 + struct rdt_domain_hdr *hdr; 594 594 + struct rmid_read rr = {0}; 595 595 + struct rdt_mon_domain *d; 596 596 + struct rdtgroup *rdtgrp; 597 597 + struct rdt_resource *r; 598 598 + struct mon_data *md; 599 599 + int domid, ret = 0; 600 600 + 601 601 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 602 602 + if (!rdtgrp) { 603 603 + ret = -ENOENT; 604 604 + goto out; 605 605 + } 606 606 + 607 607 + md = of->kn->priv; 608 608 + if (WARN_ON_ONCE(!md)) { 609 609 + ret = -EIO; 610 610 + goto out; 611 611 + } 612 612 + 613 613 + resid = md->rid; 614 614 + domid = md->domid; 615 615 + evtid = md->evtid; 616 616 + r = resctrl_arch_get_resource(resid); 617 617 + 618 618 + if (md->sum) { 619 619 + /* 620 620 + * This file requires summing across all domains that share 621 621 + * the L3 cache id that was provided in the "domid" field of the 622 622 + * struct mon_data. Search all domains in the resource for 623 623 + * one that matches this cache id. 624 624 + */ 625 625 + list_for_each_entry(d, &r->mon_domains, hdr.list) { 626 626 + if (d->ci->id == domid) { 627 627 + rr.ci = d->ci; 628 628 + mon_event_read(&rr, r, NULL, rdtgrp, 629 629 + &d->ci->shared_cpu_map, evtid, false); 630 630 + goto checkresult; 631 631 + } 632 632 + } 633 633 + ret = -ENOENT; 634 634 + goto out; 635 635 + } else { 636 636 + /* 637 637 + * This file provides data from a single domain. Search 638 638 + * the resource to find the domain with "domid". 639 639 + */ 640 640 + hdr = resctrl_find_domain(&r->mon_domains, domid, NULL); 641 641 + if (!hdr || WARN_ON_ONCE(hdr->type != RESCTRL_MON_DOMAIN)) { 642 642 + ret = -ENOENT; 643 643 + goto out; 644 644 + } 645 645 + d = container_of(hdr, struct rdt_mon_domain, hdr); 646 646 + mon_event_read(&rr, r, d, rdtgrp, &d->hdr.cpu_mask, evtid, false); 647 647 + } 648 648 + 649 649 + checkresult: 650 650 + 651 651 + if (rr.err == -EIO) 652 652 + seq_puts(m, "Error\n"); 653 653 + else if (rr.err == -EINVAL) 654 654 + seq_puts(m, "Unavailable\n"); 655 655 + else 656 656 + seq_printf(m, "%llu\n", rr.val); 657 657 + 658 658 + out: 659 659 + rdtgroup_kn_unlock(of->kn); 660 660 + return ret; 661 661 + }

+426

fs/resctrl/internal.h

reviewed

··· 1 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 2 + #ifndef _FS_RESCTRL_INTERNAL_H 3 3 + #define _FS_RESCTRL_INTERNAL_H 4 4 + 5 5 + #include <linux/resctrl.h> 6 6 + #include <linux/kernfs.h> 7 7 + #include <linux/fs_context.h> 8 8 + #include <linux/tick.h> 9 9 + 10 10 + #define CQM_LIMBOCHECK_INTERVAL 1000 11 11 + 12 12 + /** 13 13 + * cpumask_any_housekeeping() - Choose any CPU in @mask, preferring those that 14 14 + * aren't marked nohz_full 15 15 + * @mask: The mask to pick a CPU from. 16 16 + * @exclude_cpu:The CPU to avoid picking. 17 17 + * 18 18 + * Returns a CPU from @mask, but not @exclude_cpu. If there are housekeeping 19 19 + * CPUs that don't use nohz_full, these are preferred. Pass 20 20 + * RESCTRL_PICK_ANY_CPU to avoid excluding any CPUs. 21 21 + * 22 22 + * When a CPU is excluded, returns >= nr_cpu_ids if no CPUs are available. 23 23 + */ 24 24 + static inline unsigned int 25 25 + cpumask_any_housekeeping(const struct cpumask *mask, int exclude_cpu) 26 26 + { 27 27 + unsigned int cpu; 28 28 + 29 29 + /* Try to find a CPU that isn't nohz_full to use in preference */ 30 30 + if (tick_nohz_full_enabled()) { 31 31 + cpu = cpumask_any_andnot_but(mask, tick_nohz_full_mask, exclude_cpu); 32 32 + if (cpu < nr_cpu_ids) 33 33 + return cpu; 34 34 + } 35 35 + 36 36 + return cpumask_any_but(mask, exclude_cpu); 37 37 + } 38 38 + 39 39 + struct rdt_fs_context { 40 40 + struct kernfs_fs_context kfc; 41 41 + bool enable_cdpl2; 42 42 + bool enable_cdpl3; 43 43 + bool enable_mba_mbps; 44 44 + bool enable_debug; 45 45 + }; 46 46 + 47 47 + static inline struct rdt_fs_context *rdt_fc2context(struct fs_context *fc) 48 48 + { 49 49 + struct kernfs_fs_context *kfc = fc->fs_private; 50 50 + 51 51 + return container_of(kfc, struct rdt_fs_context, kfc); 52 52 + } 53 53 + 54 54 + /** 55 55 + * struct mon_evt - Entry in the event list of a resource 56 56 + * @evtid: event id 57 57 + * @name: name of the event 58 58 + * @configurable: true if the event is configurable 59 59 + * @list: entry in &rdt_resource->evt_list 60 60 + */ 61 61 + struct mon_evt { 62 62 + enum resctrl_event_id evtid; 63 63 + char *name; 64 64 + bool configurable; 65 65 + struct list_head list; 66 66 + }; 67 67 + 68 68 + /** 69 69 + * struct mon_data - Monitoring details for each event file. 70 70 + * @list: Member of the global @mon_data_kn_priv_list list. 71 71 + * @rid: Resource id associated with the event file. 72 72 + * @evtid: Event id associated with the event file. 73 73 + * @sum: Set when event must be summed across multiple 74 74 + * domains. 75 75 + * @domid: When @sum is zero this is the domain to which 76 76 + * the event file belongs. When @sum is one this 77 77 + * is the id of the L3 cache that all domains to be 78 78 + * summed share. 79 79 + * 80 80 + * Pointed to by the kernfs kn->priv field of monitoring event files. 81 81 + * Readers and writers must hold rdtgroup_mutex. 82 82 + */ 83 83 + struct mon_data { 84 84 + struct list_head list; 85 85 + enum resctrl_res_level rid; 86 86 + enum resctrl_event_id evtid; 87 87 + int domid; 88 88 + bool sum; 89 89 + }; 90 90 + 91 91 + /** 92 92 + * struct rmid_read - Data passed across smp_call*() to read event count. 93 93 + * @rgrp: Resource group for which the counter is being read. If it is a parent 94 94 + * resource group then its event count is summed with the count from all 95 95 + * its child resource groups. 96 96 + * @r: Resource describing the properties of the event being read. 97 97 + * @d: Domain that the counter should be read from. If NULL then sum all 98 98 + * domains in @r sharing L3 @ci.id 99 99 + * @evtid: Which monitor event to read. 100 100 + * @first: Initialize MBM counter when true. 101 101 + * @ci: Cacheinfo for L3. Only set when @d is NULL. Used when summing domains. 102 102 + * @err: Error encountered when reading counter. 103 103 + * @val: Returned value of event counter. If @rgrp is a parent resource group, 104 104 + * @val includes the sum of event counts from its child resource groups. 105 105 + * If @d is NULL, @val includes the sum of all domains in @r sharing @ci.id, 106 106 + * (summed across child resource groups if @rgrp is a parent resource group). 107 107 + * @arch_mon_ctx: Hardware monitor allocated for this read request (MPAM only). 108 108 + */ 109 109 + struct rmid_read { 110 110 + struct rdtgroup *rgrp; 111 111 + struct rdt_resource *r; 112 112 + struct rdt_mon_domain *d; 113 113 + enum resctrl_event_id evtid; 114 114 + bool first; 115 115 + struct cacheinfo *ci; 116 116 + int err; 117 117 + u64 val; 118 118 + void *arch_mon_ctx; 119 119 + }; 120 120 + 121 121 + extern struct list_head resctrl_schema_all; 122 122 + 123 123 + extern bool resctrl_mounted; 124 124 + 125 125 + enum rdt_group_type { 126 126 + RDTCTRL_GROUP = 0, 127 127 + RDTMON_GROUP, 128 128 + RDT_NUM_GROUP, 129 129 + }; 130 130 + 131 131 + /** 132 132 + * enum rdtgrp_mode - Mode of a RDT resource group 133 133 + * @RDT_MODE_SHAREABLE: This resource group allows sharing of its allocations 134 134 + * @RDT_MODE_EXCLUSIVE: No sharing of this resource group's allocations allowed 135 135 + * @RDT_MODE_PSEUDO_LOCKSETUP: Resource group will be used for Pseudo-Locking 136 136 + * @RDT_MODE_PSEUDO_LOCKED: No sharing of this resource group's allocations 137 137 + * allowed AND the allocations are Cache Pseudo-Locked 138 138 + * @RDT_NUM_MODES: Total number of modes 139 139 + * 140 140 + * The mode of a resource group enables control over the allowed overlap 141 141 + * between allocations associated with different resource groups (classes 142 142 + * of service). User is able to modify the mode of a resource group by 143 143 + * writing to the "mode" resctrl file associated with the resource group. 144 144 + * 145 145 + * The "shareable", "exclusive", and "pseudo-locksetup" modes are set by 146 146 + * writing the appropriate text to the "mode" file. A resource group enters 147 147 + * "pseudo-locked" mode after the schemata is written while the resource 148 148 + * group is in "pseudo-locksetup" mode. 149 149 + */ 150 150 + enum rdtgrp_mode { 151 151 + RDT_MODE_SHAREABLE = 0, 152 152 + RDT_MODE_EXCLUSIVE, 153 153 + RDT_MODE_PSEUDO_LOCKSETUP, 154 154 + RDT_MODE_PSEUDO_LOCKED, 155 155 + 156 156 + /* Must be last */ 157 157 + RDT_NUM_MODES, 158 158 + }; 159 159 + 160 160 + /** 161 161 + * struct mongroup - store mon group's data in resctrl fs. 162 162 + * @mon_data_kn: kernfs node for the mon_data directory 163 163 + * @parent: parent rdtgrp 164 164 + * @crdtgrp_list: child rdtgroup node list 165 165 + * @rmid: rmid for this rdtgroup 166 166 + */ 167 167 + struct mongroup { 168 168 + struct kernfs_node *mon_data_kn; 169 169 + struct rdtgroup *parent; 170 170 + struct list_head crdtgrp_list; 171 171 + u32 rmid; 172 172 + }; 173 173 + 174 174 + /** 175 175 + * struct rdtgroup - store rdtgroup's data in resctrl file system. 176 176 + * @kn: kernfs node 177 177 + * @rdtgroup_list: linked list for all rdtgroups 178 178 + * @closid: closid for this rdtgroup 179 179 + * @cpu_mask: CPUs assigned to this rdtgroup 180 180 + * @flags: status bits 181 181 + * @waitcount: how many cpus expect to find this 182 182 + * group when they acquire rdtgroup_mutex 183 183 + * @type: indicates type of this rdtgroup - either 184 184 + * monitor only or ctrl_mon group 185 185 + * @mon: mongroup related data 186 186 + * @mode: mode of resource group 187 187 + * @mba_mbps_event: input monitoring event id when mba_sc is enabled 188 188 + * @plr: pseudo-locked region 189 189 + */ 190 190 + struct rdtgroup { 191 191 + struct kernfs_node *kn; 192 192 + struct list_head rdtgroup_list; 193 193 + u32 closid; 194 194 + struct cpumask cpu_mask; 195 195 + int flags; 196 196 + atomic_t waitcount; 197 197 + enum rdt_group_type type; 198 198 + struct mongroup mon; 199 199 + enum rdtgrp_mode mode; 200 200 + enum resctrl_event_id mba_mbps_event; 201 201 + struct pseudo_lock_region *plr; 202 202 + }; 203 203 + 204 204 + /* rdtgroup.flags */ 205 205 + #define RDT_DELETED 1 206 206 + 207 207 + /* rftype.flags */ 208 208 + #define RFTYPE_FLAGS_CPUS_LIST 1 209 209 + 210 210 + /* 211 211 + * Define the file type flags for base and info directories. 212 212 + */ 213 213 + #define RFTYPE_INFO BIT(0) 214 214 + 215 215 + #define RFTYPE_BASE BIT(1) 216 216 + 217 217 + #define RFTYPE_CTRL BIT(4) 218 218 + 219 219 + #define RFTYPE_MON BIT(5) 220 220 + 221 221 + #define RFTYPE_TOP BIT(6) 222 222 + 223 223 + #define RFTYPE_RES_CACHE BIT(8) 224 224 + 225 225 + #define RFTYPE_RES_MB BIT(9) 226 226 + 227 227 + #define RFTYPE_DEBUG BIT(10) 228 228 + 229 229 + #define RFTYPE_CTRL_INFO (RFTYPE_INFO | RFTYPE_CTRL) 230 230 + 231 231 + #define RFTYPE_MON_INFO (RFTYPE_INFO | RFTYPE_MON) 232 232 + 233 233 + #define RFTYPE_TOP_INFO (RFTYPE_INFO | RFTYPE_TOP) 234 234 + 235 235 + #define RFTYPE_CTRL_BASE (RFTYPE_BASE | RFTYPE_CTRL) 236 236 + 237 237 + #define RFTYPE_MON_BASE (RFTYPE_BASE | RFTYPE_MON) 238 238 + 239 239 + /* List of all resource groups */ 240 240 + extern struct list_head rdt_all_groups; 241 241 + 242 242 + extern int max_name_width; 243 243 + 244 244 + /** 245 245 + * struct rftype - describe each file in the resctrl file system 246 246 + * @name: File name 247 247 + * @mode: Access mode 248 248 + * @kf_ops: File operations 249 249 + * @flags: File specific RFTYPE_FLAGS_* flags 250 250 + * @fflags: File specific RFTYPE_* flags 251 251 + * @seq_show: Show content of the file 252 252 + * @write: Write to the file 253 253 + */ 254 254 + struct rftype { 255 255 + char *name; 256 256 + umode_t mode; 257 257 + const struct kernfs_ops *kf_ops; 258 258 + unsigned long flags; 259 259 + unsigned long fflags; 260 260 + 261 261 + int (*seq_show)(struct kernfs_open_file *of, 262 262 + struct seq_file *sf, void *v); 263 263 + /* 264 264 + * write() is the generic write callback which maps directly to 265 265 + * kernfs write operation and overrides all other operations. 266 266 + * Maximum write size is determined by ->max_write_len. 267 267 + */ 268 268 + ssize_t (*write)(struct kernfs_open_file *of, 269 269 + char *buf, size_t nbytes, loff_t off); 270 270 + }; 271 271 + 272 272 + /** 273 273 + * struct mbm_state - status for each MBM counter in each domain 274 274 + * @prev_bw_bytes: Previous bytes value read for bandwidth calculation 275 275 + * @prev_bw: The most recent bandwidth in MBps 276 276 + */ 277 277 + struct mbm_state { 278 278 + u64 prev_bw_bytes; 279 279 + u32 prev_bw; 280 280 + }; 281 281 + 282 282 + extern struct mutex rdtgroup_mutex; 283 283 + 284 284 + static inline const char *rdt_kn_name(const struct kernfs_node *kn) 285 285 + { 286 286 + return rcu_dereference_check(kn->name, lockdep_is_held(&rdtgroup_mutex)); 287 287 + } 288 288 + 289 289 + extern struct rdtgroup rdtgroup_default; 290 290 + 291 291 + extern struct dentry *debugfs_resctrl; 292 292 + 293 293 + extern enum resctrl_event_id mba_mbps_default_event; 294 294 + 295 295 + void rdt_last_cmd_clear(void); 296 296 + 297 297 + void rdt_last_cmd_puts(const char *s); 298 298 + 299 299 + __printf(1, 2) 300 300 + void rdt_last_cmd_printf(const char *fmt, ...); 301 301 + 302 302 + struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn); 303 303 + 304 304 + void rdtgroup_kn_unlock(struct kernfs_node *kn); 305 305 + 306 306 + int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name); 307 307 + 308 308 + int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, 309 309 + umode_t mask); 310 310 + 311 311 + ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of, 312 312 + char *buf, size_t nbytes, loff_t off); 313 313 + 314 314 + int rdtgroup_schemata_show(struct kernfs_open_file *of, 315 315 + struct seq_file *s, void *v); 316 316 + 317 317 + ssize_t rdtgroup_mba_mbps_event_write(struct kernfs_open_file *of, 318 318 + char *buf, size_t nbytes, loff_t off); 319 319 + 320 320 + int rdtgroup_mba_mbps_event_show(struct kernfs_open_file *of, 321 321 + struct seq_file *s, void *v); 322 322 + 323 323 + bool rdtgroup_cbm_overlaps(struct resctrl_schema *s, struct rdt_ctrl_domain *d, 324 324 + unsigned long cbm, int closid, bool exclusive); 325 325 + 326 326 + unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, struct rdt_ctrl_domain *d, 327 327 + unsigned long cbm); 328 328 + 329 329 + enum rdtgrp_mode rdtgroup_mode_by_closid(int closid); 330 330 + 331 331 + int rdtgroup_tasks_assigned(struct rdtgroup *r); 332 332 + 333 333 + int closids_supported(void); 334 334 + 335 335 + void closid_free(int closid); 336 336 + 337 337 + int alloc_rmid(u32 closid); 338 338 + 339 339 + void free_rmid(u32 closid, u32 rmid); 340 340 + 341 341 + void resctrl_mon_resource_exit(void); 342 342 + 343 343 + void mon_event_count(void *info); 344 344 + 345 345 + int rdtgroup_mondata_show(struct seq_file *m, void *arg); 346 346 + 347 347 + void mon_event_read(struct rmid_read *rr, struct rdt_resource *r, 348 348 + struct rdt_mon_domain *d, struct rdtgroup *rdtgrp, 349 349 + cpumask_t *cpumask, int evtid, int first); 350 350 + 351 351 + int resctrl_mon_resource_init(void); 352 352 + 353 353 + void mbm_setup_overflow_handler(struct rdt_mon_domain *dom, 354 354 + unsigned long delay_ms, 355 355 + int exclude_cpu); 356 356 + 357 357 + void mbm_handle_overflow(struct work_struct *work); 358 358 + 359 359 + bool is_mba_sc(struct rdt_resource *r); 360 360 + 361 361 + void cqm_setup_limbo_handler(struct rdt_mon_domain *dom, unsigned long delay_ms, 362 362 + int exclude_cpu); 363 363 + 364 364 + void cqm_handle_limbo(struct work_struct *work); 365 365 + 366 366 + bool has_busy_rmid(struct rdt_mon_domain *d); 367 367 + 368 368 + void __check_limbo(struct rdt_mon_domain *d, bool force_free); 369 369 + 370 370 + void resctrl_file_fflags_init(const char *config, unsigned long fflags); 371 371 + 372 372 + void rdt_staged_configs_clear(void); 373 373 + 374 374 + bool closid_allocated(unsigned int closid); 375 375 + 376 376 + int resctrl_find_cleanest_closid(void); 377 377 + 378 378 + #ifdef CONFIG_RESCTRL_FS_PSEUDO_LOCK 379 379 + int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp); 380 380 + 381 381 + int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp); 382 382 + 383 383 + bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_ctrl_domain *d, unsigned long cbm); 384 384 + 385 385 + bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_ctrl_domain *d); 386 386 + 387 387 + int rdt_pseudo_lock_init(void); 388 388 + 389 389 + void rdt_pseudo_lock_release(void); 390 390 + 391 391 + int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp); 392 392 + 393 393 + void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp); 394 394 + 395 395 + #else 396 396 + static inline int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp) 397 397 + { 398 398 + return -EOPNOTSUPP; 399 399 + } 400 400 + 401 401 + static inline int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp) 402 402 + { 403 403 + return -EOPNOTSUPP; 404 404 + } 405 405 + 406 406 + static inline bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_ctrl_domain *d, unsigned long cbm) 407 407 + { 408 408 + return false; 409 409 + } 410 410 + 411 411 + static inline bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_ctrl_domain *d) 412 412 + { 413 413 + return false; 414 414 + } 415 415 + 416 416 + static inline int rdt_pseudo_lock_init(void) { return 0; } 417 417 + static inline void rdt_pseudo_lock_release(void) { } 418 418 + static inline int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp) 419 419 + { 420 420 + return -EOPNOTSUPP; 421 421 + } 422 422 + 423 423 + static inline void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp) { } 424 424 + #endif /* CONFIG_RESCTRL_FS_PSEUDO_LOCK */ 425 425 + 426 426 + #endif /* _FS_RESCTRL_INTERNAL_H */

+929

fs/resctrl/monitor.c

reviewed

··· 1 1 + // SPDX-License-Identifier: GPL-2.0-only 2 2 + /* 3 3 + * Resource Director Technology(RDT) 4 4 + * - Monitoring code 5 5 + * 6 6 + * Copyright (C) 2017 Intel Corporation 7 7 + * 8 8 + * Author: 9 9 + * Vikas Shivappa <vikas.shivappa@intel.com> 10 10 + * 11 11 + * This replaces the cqm.c based on perf but we reuse a lot of 12 12 + * code and datastructures originally from Peter Zijlstra and Matt Fleming. 13 13 + * 14 14 + * More information about RDT be found in the Intel (R) x86 Architecture 15 15 + * Software Developer Manual June 2016, volume 3, section 17.17. 16 16 + */ 17 17 + 18 18 + #define pr_fmt(fmt) "resctrl: " fmt 19 19 + 20 20 + #include <linux/cpu.h> 21 21 + #include <linux/resctrl.h> 22 22 + #include <linux/sizes.h> 23 23 + #include <linux/slab.h> 24 24 + 25 25 + #include "internal.h" 26 26 + 27 27 + #define CREATE_TRACE_POINTS 28 28 + 29 29 + #include "monitor_trace.h" 30 30 + 31 31 + /** 32 32 + * struct rmid_entry - dirty tracking for all RMID. 33 33 + * @closid: The CLOSID for this entry. 34 34 + * @rmid: The RMID for this entry. 35 35 + * @busy: The number of domains with cached data using this RMID. 36 36 + * @list: Member of the rmid_free_lru list when busy == 0. 37 37 + * 38 38 + * Depending on the architecture the correct monitor is accessed using 39 39 + * both @closid and @rmid, or @rmid only. 40 40 + * 41 41 + * Take the rdtgroup_mutex when accessing. 42 42 + */ 43 43 + struct rmid_entry { 44 44 + u32 closid; 45 45 + u32 rmid; 46 46 + int busy; 47 47 + struct list_head list; 48 48 + }; 49 49 + 50 50 + /* 51 51 + * @rmid_free_lru - A least recently used list of free RMIDs 52 52 + * These RMIDs are guaranteed to have an occupancy less than the 53 53 + * threshold occupancy 54 54 + */ 55 55 + static LIST_HEAD(rmid_free_lru); 56 56 + 57 57 + /* 58 58 + * @closid_num_dirty_rmid The number of dirty RMID each CLOSID has. 59 59 + * Only allocated when CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID is defined. 60 60 + * Indexed by CLOSID. Protected by rdtgroup_mutex. 61 61 + */ 62 62 + static u32 *closid_num_dirty_rmid; 63 63 + 64 64 + /* 65 65 + * @rmid_limbo_count - count of currently unused but (potentially) 66 66 + * dirty RMIDs. 67 67 + * This counts RMIDs that no one is currently using but that 68 68 + * may have a occupancy value > resctrl_rmid_realloc_threshold. User can 69 69 + * change the threshold occupancy value. 70 70 + */ 71 71 + static unsigned int rmid_limbo_count; 72 72 + 73 73 + /* 74 74 + * @rmid_entry - The entry in the limbo and free lists. 75 75 + */ 76 76 + static struct rmid_entry *rmid_ptrs; 77 77 + 78 78 + /* 79 79 + * This is the threshold cache occupancy in bytes at which we will consider an 80 80 + * RMID available for re-allocation. 81 81 + */ 82 82 + unsigned int resctrl_rmid_realloc_threshold; 83 83 + 84 84 + /* 85 85 + * This is the maximum value for the reallocation threshold, in bytes. 86 86 + */ 87 87 + unsigned int resctrl_rmid_realloc_limit; 88 88 + 89 89 + /* 90 90 + * x86 and arm64 differ in their handling of monitoring. 91 91 + * x86's RMID are independent numbers, there is only one source of traffic 92 92 + * with an RMID value of '1'. 93 93 + * arm64's PMG extends the PARTID/CLOSID space, there are multiple sources of 94 94 + * traffic with a PMG value of '1', one for each CLOSID, meaning the RMID 95 95 + * value is no longer unique. 96 96 + * To account for this, resctrl uses an index. On x86 this is just the RMID, 97 97 + * on arm64 it encodes the CLOSID and RMID. This gives a unique number. 98 98 + * 99 99 + * The domain's rmid_busy_llc and rmid_ptrs[] are sized by index. The arch code 100 100 + * must accept an attempt to read every index. 101 101 + */ 102 102 + static inline struct rmid_entry *__rmid_entry(u32 idx) 103 103 + { 104 104 + struct rmid_entry *entry; 105 105 + u32 closid, rmid; 106 106 + 107 107 + entry = &rmid_ptrs[idx]; 108 108 + resctrl_arch_rmid_idx_decode(idx, &closid, &rmid); 109 109 + 110 110 + WARN_ON_ONCE(entry->closid != closid); 111 111 + WARN_ON_ONCE(entry->rmid != rmid); 112 112 + 113 113 + return entry; 114 114 + } 115 115 + 116 116 + static void limbo_release_entry(struct rmid_entry *entry) 117 117 + { 118 118 + lockdep_assert_held(&rdtgroup_mutex); 119 119 + 120 120 + rmid_limbo_count--; 121 121 + list_add_tail(&entry->list, &rmid_free_lru); 122 122 + 123 123 + if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) 124 124 + closid_num_dirty_rmid[entry->closid]--; 125 125 + } 126 126 + 127 127 + /* 128 128 + * Check the RMIDs that are marked as busy for this domain. If the 129 129 + * reported LLC occupancy is below the threshold clear the busy bit and 130 130 + * decrement the count. If the busy count gets to zero on an RMID, we 131 131 + * free the RMID 132 132 + */ 133 133 + void __check_limbo(struct rdt_mon_domain *d, bool force_free) 134 134 + { 135 135 + struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 136 136 + u32 idx_limit = resctrl_arch_system_num_rmid_idx(); 137 137 + struct rmid_entry *entry; 138 138 + u32 idx, cur_idx = 1; 139 139 + void *arch_mon_ctx; 140 140 + bool rmid_dirty; 141 141 + u64 val = 0; 142 142 + 143 143 + arch_mon_ctx = resctrl_arch_mon_ctx_alloc(r, QOS_L3_OCCUP_EVENT_ID); 144 144 + if (IS_ERR(arch_mon_ctx)) { 145 145 + pr_warn_ratelimited("Failed to allocate monitor context: %ld", 146 146 + PTR_ERR(arch_mon_ctx)); 147 147 + return; 148 148 + } 149 149 + 150 150 + /* 151 151 + * Skip RMID 0 and start from RMID 1 and check all the RMIDs that 152 152 + * are marked as busy for occupancy < threshold. If the occupancy 153 153 + * is less than the threshold decrement the busy counter of the 154 154 + * RMID and move it to the free list when the counter reaches 0. 155 155 + */ 156 156 + for (;;) { 157 157 + idx = find_next_bit(d->rmid_busy_llc, idx_limit, cur_idx); 158 158 + if (idx >= idx_limit) 159 159 + break; 160 160 + 161 161 + entry = __rmid_entry(idx); 162 162 + if (resctrl_arch_rmid_read(r, d, entry->closid, entry->rmid, 163 163 + QOS_L3_OCCUP_EVENT_ID, &val, 164 164 + arch_mon_ctx)) { 165 165 + rmid_dirty = true; 166 166 + } else { 167 167 + rmid_dirty = (val >= resctrl_rmid_realloc_threshold); 168 168 + 169 169 + /* 170 170 + * x86's CLOSID and RMID are independent numbers, so the entry's 171 171 + * CLOSID is an empty CLOSID (X86_RESCTRL_EMPTY_CLOSID). On Arm the 172 172 + * RMID (PMG) extends the CLOSID (PARTID) space with bits that aren't 173 173 + * used to select the configuration. It is thus necessary to track both 174 174 + * CLOSID and RMID because there may be dependencies between them 175 175 + * on some architectures. 176 176 + */ 177 177 + trace_mon_llc_occupancy_limbo(entry->closid, entry->rmid, d->hdr.id, val); 178 178 + } 179 179 + 180 180 + if (force_free || !rmid_dirty) { 181 181 + clear_bit(idx, d->rmid_busy_llc); 182 182 + if (!--entry->busy) 183 183 + limbo_release_entry(entry); 184 184 + } 185 185 + cur_idx = idx + 1; 186 186 + } 187 187 + 188 188 + resctrl_arch_mon_ctx_free(r, QOS_L3_OCCUP_EVENT_ID, arch_mon_ctx); 189 189 + } 190 190 + 191 191 + bool has_busy_rmid(struct rdt_mon_domain *d) 192 192 + { 193 193 + u32 idx_limit = resctrl_arch_system_num_rmid_idx(); 194 194 + 195 195 + return find_first_bit(d->rmid_busy_llc, idx_limit) != idx_limit; 196 196 + } 197 197 + 198 198 + static struct rmid_entry *resctrl_find_free_rmid(u32 closid) 199 199 + { 200 200 + struct rmid_entry *itr; 201 201 + u32 itr_idx, cmp_idx; 202 202 + 203 203 + if (list_empty(&rmid_free_lru)) 204 204 + return rmid_limbo_count ? ERR_PTR(-EBUSY) : ERR_PTR(-ENOSPC); 205 205 + 206 206 + list_for_each_entry(itr, &rmid_free_lru, list) { 207 207 + /* 208 208 + * Get the index of this free RMID, and the index it would need 209 209 + * to be if it were used with this CLOSID. 210 210 + * If the CLOSID is irrelevant on this architecture, the two 211 211 + * index values are always the same on every entry and thus the 212 212 + * very first entry will be returned. 213 213 + */ 214 214 + itr_idx = resctrl_arch_rmid_idx_encode(itr->closid, itr->rmid); 215 215 + cmp_idx = resctrl_arch_rmid_idx_encode(closid, itr->rmid); 216 216 + 217 217 + if (itr_idx == cmp_idx) 218 218 + return itr; 219 219 + } 220 220 + 221 221 + return ERR_PTR(-ENOSPC); 222 222 + } 223 223 + 224 224 + /** 225 225 + * resctrl_find_cleanest_closid() - Find a CLOSID where all the associated 226 226 + * RMID are clean, or the CLOSID that has 227 227 + * the most clean RMID. 228 228 + * 229 229 + * MPAM's equivalent of RMID are per-CLOSID, meaning a freshly allocated CLOSID 230 230 + * may not be able to allocate clean RMID. To avoid this the allocator will 231 231 + * choose the CLOSID with the most clean RMID. 232 232 + * 233 233 + * When the CLOSID and RMID are independent numbers, the first free CLOSID will 234 234 + * be returned. 235 235 + */ 236 236 + int resctrl_find_cleanest_closid(void) 237 237 + { 238 238 + u32 cleanest_closid = ~0; 239 239 + int i = 0; 240 240 + 241 241 + lockdep_assert_held(&rdtgroup_mutex); 242 242 + 243 243 + if (!IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) 244 244 + return -EIO; 245 245 + 246 246 + for (i = 0; i < closids_supported(); i++) { 247 247 + int num_dirty; 248 248 + 249 249 + if (closid_allocated(i)) 250 250 + continue; 251 251 + 252 252 + num_dirty = closid_num_dirty_rmid[i]; 253 253 + if (num_dirty == 0) 254 254 + return i; 255 255 + 256 256 + if (cleanest_closid == ~0) 257 257 + cleanest_closid = i; 258 258 + 259 259 + if (num_dirty < closid_num_dirty_rmid[cleanest_closid]) 260 260 + cleanest_closid = i; 261 261 + } 262 262 + 263 263 + if (cleanest_closid == ~0) 264 264 + return -ENOSPC; 265 265 + 266 266 + return cleanest_closid; 267 267 + } 268 268 + 269 269 + /* 270 270 + * For MPAM the RMID value is not unique, and has to be considered with 271 271 + * the CLOSID. The (CLOSID, RMID) pair is allocated on all domains, which 272 272 + * allows all domains to be managed by a single free list. 273 273 + * Each domain also has a rmid_busy_llc to reduce the work of the limbo handler. 274 274 + */ 275 275 + int alloc_rmid(u32 closid) 276 276 + { 277 277 + struct rmid_entry *entry; 278 278 + 279 279 + lockdep_assert_held(&rdtgroup_mutex); 280 280 + 281 281 + entry = resctrl_find_free_rmid(closid); 282 282 + if (IS_ERR(entry)) 283 283 + return PTR_ERR(entry); 284 284 + 285 285 + list_del(&entry->list); 286 286 + return entry->rmid; 287 287 + } 288 288 + 289 289 + static void add_rmid_to_limbo(struct rmid_entry *entry) 290 290 + { 291 291 + struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 292 292 + struct rdt_mon_domain *d; 293 293 + u32 idx; 294 294 + 295 295 + lockdep_assert_held(&rdtgroup_mutex); 296 296 + 297 297 + /* Walking r->domains, ensure it can't race with cpuhp */ 298 298 + lockdep_assert_cpus_held(); 299 299 + 300 300 + idx = resctrl_arch_rmid_idx_encode(entry->closid, entry->rmid); 301 301 + 302 302 + entry->busy = 0; 303 303 + list_for_each_entry(d, &r->mon_domains, hdr.list) { 304 304 + /* 305 305 + * For the first limbo RMID in the domain, 306 306 + * setup up the limbo worker. 307 307 + */ 308 308 + if (!has_busy_rmid(d)) 309 309 + cqm_setup_limbo_handler(d, CQM_LIMBOCHECK_INTERVAL, 310 310 + RESCTRL_PICK_ANY_CPU); 311 311 + set_bit(idx, d->rmid_busy_llc); 312 312 + entry->busy++; 313 313 + } 314 314 + 315 315 + rmid_limbo_count++; 316 316 + if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) 317 317 + closid_num_dirty_rmid[entry->closid]++; 318 318 + } 319 319 + 320 320 + void free_rmid(u32 closid, u32 rmid) 321 321 + { 322 322 + u32 idx = resctrl_arch_rmid_idx_encode(closid, rmid); 323 323 + struct rmid_entry *entry; 324 324 + 325 325 + lockdep_assert_held(&rdtgroup_mutex); 326 326 + 327 327 + /* 328 328 + * Do not allow the default rmid to be free'd. Comparing by index 329 329 + * allows architectures that ignore the closid parameter to avoid an 330 330 + * unnecessary check. 331 331 + */ 332 332 + if (!resctrl_arch_mon_capable() || 333 333 + idx == resctrl_arch_rmid_idx_encode(RESCTRL_RESERVED_CLOSID, 334 334 + RESCTRL_RESERVED_RMID)) 335 335 + return; 336 336 + 337 337 + entry = __rmid_entry(idx); 338 338 + 339 339 + if (resctrl_arch_is_llc_occupancy_enabled()) 340 340 + add_rmid_to_limbo(entry); 341 341 + else 342 342 + list_add_tail(&entry->list, &rmid_free_lru); 343 343 + } 344 344 + 345 345 + static struct mbm_state *get_mbm_state(struct rdt_mon_domain *d, u32 closid, 346 346 + u32 rmid, enum resctrl_event_id evtid) 347 347 + { 348 348 + u32 idx = resctrl_arch_rmid_idx_encode(closid, rmid); 349 349 + 350 350 + switch (evtid) { 351 351 + case QOS_L3_MBM_TOTAL_EVENT_ID: 352 352 + return &d->mbm_total[idx]; 353 353 + case QOS_L3_MBM_LOCAL_EVENT_ID: 354 354 + return &d->mbm_local[idx]; 355 355 + default: 356 356 + return NULL; 357 357 + } 358 358 + } 359 359 + 360 360 + static int __mon_event_count(u32 closid, u32 rmid, struct rmid_read *rr) 361 361 + { 362 362 + int cpu = smp_processor_id(); 363 363 + struct rdt_mon_domain *d; 364 364 + struct mbm_state *m; 365 365 + int err, ret; 366 366 + u64 tval = 0; 367 367 + 368 368 + if (rr->first) { 369 369 + resctrl_arch_reset_rmid(rr->r, rr->d, closid, rmid, rr->evtid); 370 370 + m = get_mbm_state(rr->d, closid, rmid, rr->evtid); 371 371 + if (m) 372 372 + memset(m, 0, sizeof(struct mbm_state)); 373 373 + return 0; 374 374 + } 375 375 + 376 376 + if (rr->d) { 377 377 + /* Reading a single domain, must be on a CPU in that domain. */ 378 378 + if (!cpumask_test_cpu(cpu, &rr->d->hdr.cpu_mask)) 379 379 + return -EINVAL; 380 380 + rr->err = resctrl_arch_rmid_read(rr->r, rr->d, closid, rmid, 381 381 + rr->evtid, &tval, rr->arch_mon_ctx); 382 382 + if (rr->err) 383 383 + return rr->err; 384 384 + 385 385 + rr->val += tval; 386 386 + 387 387 + return 0; 388 388 + } 389 389 + 390 390 + /* Summing domains that share a cache, must be on a CPU for that cache. */ 391 391 + if (!cpumask_test_cpu(cpu, &rr->ci->shared_cpu_map)) 392 392 + return -EINVAL; 393 393 + 394 394 + /* 395 395 + * Legacy files must report the sum of an event across all 396 396 + * domains that share the same L3 cache instance. 397 397 + * Report success if a read from any domain succeeds, -EINVAL 398 398 + * (translated to "Unavailable" for user space) if reading from 399 399 + * all domains fail for any reason. 400 400 + */ 401 401 + ret = -EINVAL; 402 402 + list_for_each_entry(d, &rr->r->mon_domains, hdr.list) { 403 403 + if (d->ci->id != rr->ci->id) 404 404 + continue; 405 405 + err = resctrl_arch_rmid_read(rr->r, d, closid, rmid, 406 406 + rr->evtid, &tval, rr->arch_mon_ctx); 407 407 + if (!err) { 408 408 + rr->val += tval; 409 409 + ret = 0; 410 410 + } 411 411 + } 412 412 + 413 413 + if (ret) 414 414 + rr->err = ret; 415 415 + 416 416 + return ret; 417 417 + } 418 418 + 419 419 + /* 420 420 + * mbm_bw_count() - Update bw count from values previously read by 421 421 + * __mon_event_count(). 422 422 + * @closid: The closid used to identify the cached mbm_state. 423 423 + * @rmid: The rmid used to identify the cached mbm_state. 424 424 + * @rr: The struct rmid_read populated by __mon_event_count(). 425 425 + * 426 426 + * Supporting function to calculate the memory bandwidth 427 427 + * and delta bandwidth in MBps. The chunks value previously read by 428 428 + * __mon_event_count() is compared with the chunks value from the previous 429 429 + * invocation. This must be called once per second to maintain values in MBps. 430 430 + */ 431 431 + static void mbm_bw_count(u32 closid, u32 rmid, struct rmid_read *rr) 432 432 + { 433 433 + u64 cur_bw, bytes, cur_bytes; 434 434 + struct mbm_state *m; 435 435 + 436 436 + m = get_mbm_state(rr->d, closid, rmid, rr->evtid); 437 437 + if (WARN_ON_ONCE(!m)) 438 438 + return; 439 439 + 440 440 + cur_bytes = rr->val; 441 441 + bytes = cur_bytes - m->prev_bw_bytes; 442 442 + m->prev_bw_bytes = cur_bytes; 443 443 + 444 444 + cur_bw = bytes / SZ_1M; 445 445 + 446 446 + m->prev_bw = cur_bw; 447 447 + } 448 448 + 449 449 + /* 450 450 + * This is scheduled by mon_event_read() to read the CQM/MBM counters 451 451 + * on a domain. 452 452 + */ 453 453 + void mon_event_count(void *info) 454 454 + { 455 455 + struct rdtgroup *rdtgrp, *entry; 456 456 + struct rmid_read *rr = info; 457 457 + struct list_head *head; 458 458 + int ret; 459 459 + 460 460 + rdtgrp = rr->rgrp; 461 461 + 462 462 + ret = __mon_event_count(rdtgrp->closid, rdtgrp->mon.rmid, rr); 463 463 + 464 464 + /* 465 465 + * For Ctrl groups read data from child monitor groups and 466 466 + * add them together. Count events which are read successfully. 467 467 + * Discard the rmid_read's reporting errors. 468 468 + */ 469 469 + head = &rdtgrp->mon.crdtgrp_list; 470 470 + 471 471 + if (rdtgrp->type == RDTCTRL_GROUP) { 472 472 + list_for_each_entry(entry, head, mon.crdtgrp_list) { 473 473 + if (__mon_event_count(entry->closid, entry->mon.rmid, 474 474 + rr) == 0) 475 475 + ret = 0; 476 476 + } 477 477 + } 478 478 + 479 479 + /* 480 480 + * __mon_event_count() calls for newly created monitor groups may 481 481 + * report -EINVAL/Unavailable if the monitor hasn't seen any traffic. 482 482 + * Discard error if any of the monitor event reads succeeded. 483 483 + */ 484 484 + if (ret == 0) 485 485 + rr->err = 0; 486 486 + } 487 487 + 488 488 + static struct rdt_ctrl_domain *get_ctrl_domain_from_cpu(int cpu, 489 489 + struct rdt_resource *r) 490 490 + { 491 491 + struct rdt_ctrl_domain *d; 492 492 + 493 493 + lockdep_assert_cpus_held(); 494 494 + 495 495 + list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 496 496 + /* Find the domain that contains this CPU */ 497 497 + if (cpumask_test_cpu(cpu, &d->hdr.cpu_mask)) 498 498 + return d; 499 499 + } 500 500 + 501 501 + return NULL; 502 502 + } 503 503 + 504 504 + /* 505 505 + * Feedback loop for MBA software controller (mba_sc) 506 506 + * 507 507 + * mba_sc is a feedback loop where we periodically read MBM counters and 508 508 + * adjust the bandwidth percentage values via the IA32_MBA_THRTL_MSRs so 509 509 + * that: 510 510 + * 511 511 + * current bandwidth(cur_bw) < user specified bandwidth(user_bw) 512 512 + * 513 513 + * This uses the MBM counters to measure the bandwidth and MBA throttle 514 514 + * MSRs to control the bandwidth for a particular rdtgrp. It builds on the 515 515 + * fact that resctrl rdtgroups have both monitoring and control. 516 516 + * 517 517 + * The frequency of the checks is 1s and we just tag along the MBM overflow 518 518 + * timer. Having 1s interval makes the calculation of bandwidth simpler. 519 519 + * 520 520 + * Although MBA's goal is to restrict the bandwidth to a maximum, there may 521 521 + * be a need to increase the bandwidth to avoid unnecessarily restricting 522 522 + * the L2 <-> L3 traffic. 523 523 + * 524 524 + * Since MBA controls the L2 external bandwidth where as MBM measures the 525 525 + * L3 external bandwidth the following sequence could lead to such a 526 526 + * situation. 527 527 + * 528 528 + * Consider an rdtgroup which had high L3 <-> memory traffic in initial 529 529 + * phases -> mba_sc kicks in and reduced bandwidth percentage values -> but 530 530 + * after some time rdtgroup has mostly L2 <-> L3 traffic. 531 531 + * 532 532 + * In this case we may restrict the rdtgroup's L2 <-> L3 traffic as its 533 533 + * throttle MSRs already have low percentage values. To avoid 534 534 + * unnecessarily restricting such rdtgroups, we also increase the bandwidth. 535 535 + */ 536 536 + static void update_mba_bw(struct rdtgroup *rgrp, struct rdt_mon_domain *dom_mbm) 537 537 + { 538 538 + u32 closid, rmid, cur_msr_val, new_msr_val; 539 539 + struct mbm_state *pmbm_data, *cmbm_data; 540 540 + struct rdt_ctrl_domain *dom_mba; 541 541 + enum resctrl_event_id evt_id; 542 542 + struct rdt_resource *r_mba; 543 543 + struct list_head *head; 544 544 + struct rdtgroup *entry; 545 545 + u32 cur_bw, user_bw; 546 546 + 547 547 + r_mba = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 548 548 + evt_id = rgrp->mba_mbps_event; 549 549 + 550 550 + closid = rgrp->closid; 551 551 + rmid = rgrp->mon.rmid; 552 552 + pmbm_data = get_mbm_state(dom_mbm, closid, rmid, evt_id); 553 553 + if (WARN_ON_ONCE(!pmbm_data)) 554 554 + return; 555 555 + 556 556 + dom_mba = get_ctrl_domain_from_cpu(smp_processor_id(), r_mba); 557 557 + if (!dom_mba) { 558 558 + pr_warn_once("Failure to get domain for MBA update\n"); 559 559 + return; 560 560 + } 561 561 + 562 562 + cur_bw = pmbm_data->prev_bw; 563 563 + user_bw = dom_mba->mbps_val[closid]; 564 564 + 565 565 + /* MBA resource doesn't support CDP */ 566 566 + cur_msr_val = resctrl_arch_get_config(r_mba, dom_mba, closid, CDP_NONE); 567 567 + 568 568 + /* 569 569 + * For Ctrl groups read data from child monitor groups. 570 570 + */ 571 571 + head = &rgrp->mon.crdtgrp_list; 572 572 + list_for_each_entry(entry, head, mon.crdtgrp_list) { 573 573 + cmbm_data = get_mbm_state(dom_mbm, entry->closid, entry->mon.rmid, evt_id); 574 574 + if (WARN_ON_ONCE(!cmbm_data)) 575 575 + return; 576 576 + cur_bw += cmbm_data->prev_bw; 577 577 + } 578 578 + 579 579 + /* 580 580 + * Scale up/down the bandwidth linearly for the ctrl group. The 581 581 + * bandwidth step is the bandwidth granularity specified by the 582 582 + * hardware. 583 583 + * Always increase throttling if current bandwidth is above the 584 584 + * target set by user. 585 585 + * But avoid thrashing up and down on every poll by checking 586 586 + * whether a decrease in throttling is likely to push the group 587 587 + * back over target. E.g. if currently throttling to 30% of bandwidth 588 588 + * on a system with 10% granularity steps, check whether moving to 589 589 + * 40% would go past the limit by multiplying current bandwidth by 590 590 + * "(30 + 10) / 30". 591 591 + */ 592 592 + if (cur_msr_val > r_mba->membw.min_bw && user_bw < cur_bw) { 593 593 + new_msr_val = cur_msr_val - r_mba->membw.bw_gran; 594 594 + } else if (cur_msr_val < MAX_MBA_BW && 595 595 + (user_bw > (cur_bw * (cur_msr_val + r_mba->membw.min_bw) / cur_msr_val))) { 596 596 + new_msr_val = cur_msr_val + r_mba->membw.bw_gran; 597 597 + } else { 598 598 + return; 599 599 + } 600 600 + 601 601 + resctrl_arch_update_one(r_mba, dom_mba, closid, CDP_NONE, new_msr_val); 602 602 + } 603 603 + 604 604 + static void mbm_update_one_event(struct rdt_resource *r, struct rdt_mon_domain *d, 605 605 + u32 closid, u32 rmid, enum resctrl_event_id evtid) 606 606 + { 607 607 + struct rmid_read rr = {0}; 608 608 + 609 609 + rr.r = r; 610 610 + rr.d = d; 611 611 + rr.evtid = evtid; 612 612 + rr.arch_mon_ctx = resctrl_arch_mon_ctx_alloc(rr.r, rr.evtid); 613 613 + if (IS_ERR(rr.arch_mon_ctx)) { 614 614 + pr_warn_ratelimited("Failed to allocate monitor context: %ld", 615 615 + PTR_ERR(rr.arch_mon_ctx)); 616 616 + return; 617 617 + } 618 618 + 619 619 + __mon_event_count(closid, rmid, &rr); 620 620 + 621 621 + /* 622 622 + * If the software controller is enabled, compute the 623 623 + * bandwidth for this event id. 624 624 + */ 625 625 + if (is_mba_sc(NULL)) 626 626 + mbm_bw_count(closid, rmid, &rr); 627 627 + 628 628 + resctrl_arch_mon_ctx_free(rr.r, rr.evtid, rr.arch_mon_ctx); 629 629 + } 630 630 + 631 631 + static void mbm_update(struct rdt_resource *r, struct rdt_mon_domain *d, 632 632 + u32 closid, u32 rmid) 633 633 + { 634 634 + /* 635 635 + * This is protected from concurrent reads from user as both 636 636 + * the user and overflow handler hold the global mutex. 637 637 + */ 638 638 + if (resctrl_arch_is_mbm_total_enabled()) 639 639 + mbm_update_one_event(r, d, closid, rmid, QOS_L3_MBM_TOTAL_EVENT_ID); 640 640 + 641 641 + if (resctrl_arch_is_mbm_local_enabled()) 642 642 + mbm_update_one_event(r, d, closid, rmid, QOS_L3_MBM_LOCAL_EVENT_ID); 643 643 + } 644 644 + 645 645 + /* 646 646 + * Handler to scan the limbo list and move the RMIDs 647 647 + * to free list whose occupancy < threshold_occupancy. 648 648 + */ 649 649 + void cqm_handle_limbo(struct work_struct *work) 650 650 + { 651 651 + unsigned long delay = msecs_to_jiffies(CQM_LIMBOCHECK_INTERVAL); 652 652 + struct rdt_mon_domain *d; 653 653 + 654 654 + cpus_read_lock(); 655 655 + mutex_lock(&rdtgroup_mutex); 656 656 + 657 657 + d = container_of(work, struct rdt_mon_domain, cqm_limbo.work); 658 658 + 659 659 + __check_limbo(d, false); 660 660 + 661 661 + if (has_busy_rmid(d)) { 662 662 + d->cqm_work_cpu = cpumask_any_housekeeping(&d->hdr.cpu_mask, 663 663 + RESCTRL_PICK_ANY_CPU); 664 664 + schedule_delayed_work_on(d->cqm_work_cpu, &d->cqm_limbo, 665 665 + delay); 666 666 + } 667 667 + 668 668 + mutex_unlock(&rdtgroup_mutex); 669 669 + cpus_read_unlock(); 670 670 + } 671 671 + 672 672 + /** 673 673 + * cqm_setup_limbo_handler() - Schedule the limbo handler to run for this 674 674 + * domain. 675 675 + * @dom: The domain the limbo handler should run for. 676 676 + * @delay_ms: How far in the future the handler should run. 677 677 + * @exclude_cpu: Which CPU the handler should not run on, 678 678 + * RESCTRL_PICK_ANY_CPU to pick any CPU. 679 679 + */ 680 680 + void cqm_setup_limbo_handler(struct rdt_mon_domain *dom, unsigned long delay_ms, 681 681 + int exclude_cpu) 682 682 + { 683 683 + unsigned long delay = msecs_to_jiffies(delay_ms); 684 684 + int cpu; 685 685 + 686 686 + cpu = cpumask_any_housekeeping(&dom->hdr.cpu_mask, exclude_cpu); 687 687 + dom->cqm_work_cpu = cpu; 688 688 + 689 689 + if (cpu < nr_cpu_ids) 690 690 + schedule_delayed_work_on(cpu, &dom->cqm_limbo, delay); 691 691 + } 692 692 + 693 693 + void mbm_handle_overflow(struct work_struct *work) 694 694 + { 695 695 + unsigned long delay = msecs_to_jiffies(MBM_OVERFLOW_INTERVAL); 696 696 + struct rdtgroup *prgrp, *crgrp; 697 697 + struct rdt_mon_domain *d; 698 698 + struct list_head *head; 699 699 + struct rdt_resource *r; 700 700 + 701 701 + cpus_read_lock(); 702 702 + mutex_lock(&rdtgroup_mutex); 703 703 + 704 704 + /* 705 705 + * If the filesystem has been unmounted this work no longer needs to 706 706 + * run. 707 707 + */ 708 708 + if (!resctrl_mounted || !resctrl_arch_mon_capable()) 709 709 + goto out_unlock; 710 710 + 711 711 + r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 712 712 + d = container_of(work, struct rdt_mon_domain, mbm_over.work); 713 713 + 714 714 + list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 715 715 + mbm_update(r, d, prgrp->closid, prgrp->mon.rmid); 716 716 + 717 717 + head = &prgrp->mon.crdtgrp_list; 718 718 + list_for_each_entry(crgrp, head, mon.crdtgrp_list) 719 719 + mbm_update(r, d, crgrp->closid, crgrp->mon.rmid); 720 720 + 721 721 + if (is_mba_sc(NULL)) 722 722 + update_mba_bw(prgrp, d); 723 723 + } 724 724 + 725 725 + /* 726 726 + * Re-check for housekeeping CPUs. This allows the overflow handler to 727 727 + * move off a nohz_full CPU quickly. 728 728 + */ 729 729 + d->mbm_work_cpu = cpumask_any_housekeeping(&d->hdr.cpu_mask, 730 730 + RESCTRL_PICK_ANY_CPU); 731 731 + schedule_delayed_work_on(d->mbm_work_cpu, &d->mbm_over, delay); 732 732 + 733 733 + out_unlock: 734 734 + mutex_unlock(&rdtgroup_mutex); 735 735 + cpus_read_unlock(); 736 736 + } 737 737 + 738 738 + /** 739 739 + * mbm_setup_overflow_handler() - Schedule the overflow handler to run for this 740 740 + * domain. 741 741 + * @dom: The domain the overflow handler should run for. 742 742 + * @delay_ms: How far in the future the handler should run. 743 743 + * @exclude_cpu: Which CPU the handler should not run on, 744 744 + * RESCTRL_PICK_ANY_CPU to pick any CPU. 745 745 + */ 746 746 + void mbm_setup_overflow_handler(struct rdt_mon_domain *dom, unsigned long delay_ms, 747 747 + int exclude_cpu) 748 748 + { 749 749 + unsigned long delay = msecs_to_jiffies(delay_ms); 750 750 + int cpu; 751 751 + 752 752 + /* 753 753 + * When a domain comes online there is no guarantee the filesystem is 754 754 + * mounted. If not, there is no need to catch counter overflow. 755 755 + */ 756 756 + if (!resctrl_mounted || !resctrl_arch_mon_capable()) 757 757 + return; 758 758 + cpu = cpumask_any_housekeeping(&dom->hdr.cpu_mask, exclude_cpu); 759 759 + dom->mbm_work_cpu = cpu; 760 760 + 761 761 + if (cpu < nr_cpu_ids) 762 762 + schedule_delayed_work_on(cpu, &dom->mbm_over, delay); 763 763 + } 764 764 + 765 765 + static int dom_data_init(struct rdt_resource *r) 766 766 + { 767 767 + u32 idx_limit = resctrl_arch_system_num_rmid_idx(); 768 768 + u32 num_closid = resctrl_arch_get_num_closid(r); 769 769 + struct rmid_entry *entry = NULL; 770 770 + int err = 0, i; 771 771 + u32 idx; 772 772 + 773 773 + mutex_lock(&rdtgroup_mutex); 774 774 + if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) { 775 775 + u32 *tmp; 776 776 + 777 777 + /* 778 778 + * If the architecture hasn't provided a sanitised value here, 779 779 + * this may result in larger arrays than necessary. Resctrl will 780 780 + * use a smaller system wide value based on the resources in 781 781 + * use. 782 782 + */ 783 783 + tmp = kcalloc(num_closid, sizeof(*tmp), GFP_KERNEL); 784 784 + if (!tmp) { 785 785 + err = -ENOMEM; 786 786 + goto out_unlock; 787 787 + } 788 788 + 789 789 + closid_num_dirty_rmid = tmp; 790 790 + } 791 791 + 792 792 + rmid_ptrs = kcalloc(idx_limit, sizeof(struct rmid_entry), GFP_KERNEL); 793 793 + if (!rmid_ptrs) { 794 794 + if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) { 795 795 + kfree(closid_num_dirty_rmid); 796 796 + closid_num_dirty_rmid = NULL; 797 797 + } 798 798 + err = -ENOMEM; 799 799 + goto out_unlock; 800 800 + } 801 801 + 802 802 + for (i = 0; i < idx_limit; i++) { 803 803 + entry = &rmid_ptrs[i]; 804 804 + INIT_LIST_HEAD(&entry->list); 805 805 + 806 806 + resctrl_arch_rmid_idx_decode(i, &entry->closid, &entry->rmid); 807 807 + list_add_tail(&entry->list, &rmid_free_lru); 808 808 + } 809 809 + 810 810 + /* 811 811 + * RESCTRL_RESERVED_CLOSID and RESCTRL_RESERVED_RMID are special and 812 812 + * are always allocated. These are used for the rdtgroup_default 813 813 + * control group, which will be setup later in resctrl_init(). 814 814 + */ 815 815 + idx = resctrl_arch_rmid_idx_encode(RESCTRL_RESERVED_CLOSID, 816 816 + RESCTRL_RESERVED_RMID); 817 817 + entry = __rmid_entry(idx); 818 818 + list_del(&entry->list); 819 819 + 820 820 + out_unlock: 821 821 + mutex_unlock(&rdtgroup_mutex); 822 822 + 823 823 + return err; 824 824 + } 825 825 + 826 826 + static void dom_data_exit(struct rdt_resource *r) 827 827 + { 828 828 + mutex_lock(&rdtgroup_mutex); 829 829 + 830 830 + if (!r->mon_capable) 831 831 + goto out_unlock; 832 832 + 833 833 + if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID)) { 834 834 + kfree(closid_num_dirty_rmid); 835 835 + closid_num_dirty_rmid = NULL; 836 836 + } 837 837 + 838 838 + kfree(rmid_ptrs); 839 839 + rmid_ptrs = NULL; 840 840 + 841 841 + out_unlock: 842 842 + mutex_unlock(&rdtgroup_mutex); 843 843 + } 844 844 + 845 845 + static struct mon_evt llc_occupancy_event = { 846 846 + .name = "llc_occupancy", 847 847 + .evtid = QOS_L3_OCCUP_EVENT_ID, 848 848 + }; 849 849 + 850 850 + static struct mon_evt mbm_total_event = { 851 851 + .name = "mbm_total_bytes", 852 852 + .evtid = QOS_L3_MBM_TOTAL_EVENT_ID, 853 853 + }; 854 854 + 855 855 + static struct mon_evt mbm_local_event = { 856 856 + .name = "mbm_local_bytes", 857 857 + .evtid = QOS_L3_MBM_LOCAL_EVENT_ID, 858 858 + }; 859 859 + 860 860 + /* 861 861 + * Initialize the event list for the resource. 862 862 + * 863 863 + * Note that MBM events are also part of RDT_RESOURCE_L3 resource 864 864 + * because as per the SDM the total and local memory bandwidth 865 865 + * are enumerated as part of L3 monitoring. 866 866 + */ 867 867 + static void l3_mon_evt_init(struct rdt_resource *r) 868 868 + { 869 869 + INIT_LIST_HEAD(&r->evt_list); 870 870 + 871 871 + if (resctrl_arch_is_llc_occupancy_enabled()) 872 872 + list_add_tail(&llc_occupancy_event.list, &r->evt_list); 873 873 + if (resctrl_arch_is_mbm_total_enabled()) 874 874 + list_add_tail(&mbm_total_event.list, &r->evt_list); 875 875 + if (resctrl_arch_is_mbm_local_enabled()) 876 876 + list_add_tail(&mbm_local_event.list, &r->evt_list); 877 877 + } 878 878 + 879 879 + /** 880 880 + * resctrl_mon_resource_init() - Initialise global monitoring structures. 881 881 + * 882 882 + * Allocate and initialise global monitor resources that do not belong to a 883 883 + * specific domain. i.e. the rmid_ptrs[] used for the limbo and free lists. 884 884 + * Called once during boot after the struct rdt_resource's have been configured 885 885 + * but before the filesystem is mounted. 886 886 + * Resctrl's cpuhp callbacks may be called before this point to bring a domain 887 887 + * online. 888 888 + * 889 889 + * Returns 0 for success, or -ENOMEM. 890 890 + */ 891 891 + int resctrl_mon_resource_init(void) 892 892 + { 893 893 + struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 894 894 + int ret; 895 895 + 896 896 + if (!r->mon_capable) 897 897 + return 0; 898 898 + 899 899 + ret = dom_data_init(r); 900 900 + if (ret) 901 901 + return ret; 902 902 + 903 903 + l3_mon_evt_init(r); 904 904 + 905 905 + if (resctrl_arch_is_evt_configurable(QOS_L3_MBM_TOTAL_EVENT_ID)) { 906 906 + mbm_total_event.configurable = true; 907 907 + resctrl_file_fflags_init("mbm_total_bytes_config", 908 908 + RFTYPE_MON_INFO | RFTYPE_RES_CACHE); 909 909 + } 910 910 + if (resctrl_arch_is_evt_configurable(QOS_L3_MBM_LOCAL_EVENT_ID)) { 911 911 + mbm_local_event.configurable = true; 912 912 + resctrl_file_fflags_init("mbm_local_bytes_config", 913 913 + RFTYPE_MON_INFO | RFTYPE_RES_CACHE); 914 914 + } 915 915 + 916 916 + if (resctrl_arch_is_mbm_local_enabled()) 917 917 + mba_mbps_default_event = QOS_L3_MBM_LOCAL_EVENT_ID; 918 918 + else if (resctrl_arch_is_mbm_total_enabled()) 919 919 + mba_mbps_default_event = QOS_L3_MBM_TOTAL_EVENT_ID; 920 920 + 921 921 + return 0; 922 922 + } 923 923 + 924 924 + void resctrl_mon_resource_exit(void) 925 925 + { 926 926 + struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 927 927 + 928 928 + dom_data_exit(r); 929 929 + }

+33

fs/resctrl/monitor_trace.h

reviewed

··· 1 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 2 + #undef TRACE_SYSTEM 3 3 + #define TRACE_SYSTEM resctrl 4 4 + 5 5 + #if !defined(_FS_RESCTRL_MONITOR_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) 6 6 + #define _FS_RESCTRL_MONITOR_TRACE_H 7 7 + 8 8 + #include <linux/tracepoint.h> 9 9 + 10 10 + TRACE_EVENT(mon_llc_occupancy_limbo, 11 11 + TP_PROTO(u32 ctrl_hw_id, u32 mon_hw_id, int domain_id, u64 llc_occupancy_bytes), 12 12 + TP_ARGS(ctrl_hw_id, mon_hw_id, domain_id, llc_occupancy_bytes), 13 13 + TP_STRUCT__entry(__field(u32, ctrl_hw_id) 14 14 + __field(u32, mon_hw_id) 15 15 + __field(int, domain_id) 16 16 + __field(u64, llc_occupancy_bytes)), 17 17 + TP_fast_assign(__entry->ctrl_hw_id = ctrl_hw_id; 18 18 + __entry->mon_hw_id = mon_hw_id; 19 19 + __entry->domain_id = domain_id; 20 20 + __entry->llc_occupancy_bytes = llc_occupancy_bytes;), 21 21 + TP_printk("ctrl_hw_id=%u mon_hw_id=%u domain_id=%d llc_occupancy_bytes=%llu", 22 22 + __entry->ctrl_hw_id, __entry->mon_hw_id, __entry->domain_id, 23 23 + __entry->llc_occupancy_bytes) 24 24 + ); 25 25 + 26 26 + #endif /* _FS_RESCTRL_MONITOR_TRACE_H */ 27 27 + 28 28 + #undef TRACE_INCLUDE_PATH 29 29 + #define TRACE_INCLUDE_PATH . 30 30 + 31 31 + #define TRACE_INCLUDE_FILE monitor_trace 32 32 + 33 33 + #include <trace/define_trace.h>

+1105

fs/resctrl/pseudo_lock.c

reviewed

··· 1 1 + // SPDX-License-Identifier: GPL-2.0 2 2 + /* 3 3 + * Resource Director Technology (RDT) 4 4 + * 5 5 + * Pseudo-locking support built on top of Cache Allocation Technology (CAT) 6 6 + * 7 7 + * Copyright (C) 2018 Intel Corporation 8 8 + * 9 9 + * Author: Reinette Chatre <reinette.chatre@intel.com> 10 10 + */ 11 11 + 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 14 14 + #include <linux/cacheinfo.h> 15 15 + #include <linux/cpu.h> 16 16 + #include <linux/cpumask.h> 17 17 + #include <linux/debugfs.h> 18 18 + #include <linux/kthread.h> 19 19 + #include <linux/mman.h> 20 20 + #include <linux/pm_qos.h> 21 21 + #include <linux/resctrl.h> 22 22 + #include <linux/slab.h> 23 23 + #include <linux/uaccess.h> 24 24 + 25 25 + #include "internal.h" 26 26 + 27 27 + /* 28 28 + * Major number assigned to and shared by all devices exposing 29 29 + * pseudo-locked regions. 30 30 + */ 31 31 + static unsigned int pseudo_lock_major; 32 32 + 33 33 + static unsigned long pseudo_lock_minor_avail = GENMASK(MINORBITS, 0); 34 34 + 35 35 + static char *pseudo_lock_devnode(const struct device *dev, umode_t *mode) 36 36 + { 37 37 + const struct rdtgroup *rdtgrp; 38 38 + 39 39 + rdtgrp = dev_get_drvdata(dev); 40 40 + if (mode) 41 41 + *mode = 0600; 42 42 + guard(mutex)(&rdtgroup_mutex); 43 43 + return kasprintf(GFP_KERNEL, "pseudo_lock/%s", rdt_kn_name(rdtgrp->kn)); 44 44 + } 45 45 + 46 46 + static const struct class pseudo_lock_class = { 47 47 + .name = "pseudo_lock", 48 48 + .devnode = pseudo_lock_devnode, 49 49 + }; 50 50 + 51 51 + /** 52 52 + * pseudo_lock_minor_get - Obtain available minor number 53 53 + * @minor: Pointer to where new minor number will be stored 54 54 + * 55 55 + * A bitmask is used to track available minor numbers. Here the next free 56 56 + * minor number is marked as unavailable and returned. 57 57 + * 58 58 + * Return: 0 on success, <0 on failure. 59 59 + */ 60 60 + static int pseudo_lock_minor_get(unsigned int *minor) 61 61 + { 62 62 + unsigned long first_bit; 63 63 + 64 64 + first_bit = find_first_bit(&pseudo_lock_minor_avail, MINORBITS); 65 65 + 66 66 + if (first_bit == MINORBITS) 67 67 + return -ENOSPC; 68 68 + 69 69 + __clear_bit(first_bit, &pseudo_lock_minor_avail); 70 70 + *minor = first_bit; 71 71 + 72 72 + return 0; 73 73 + } 74 74 + 75 75 + /** 76 76 + * pseudo_lock_minor_release - Return minor number to available 77 77 + * @minor: The minor number made available 78 78 + */ 79 79 + static void pseudo_lock_minor_release(unsigned int minor) 80 80 + { 81 81 + __set_bit(minor, &pseudo_lock_minor_avail); 82 82 + } 83 83 + 84 84 + /** 85 85 + * region_find_by_minor - Locate a pseudo-lock region by inode minor number 86 86 + * @minor: The minor number of the device representing pseudo-locked region 87 87 + * 88 88 + * When the character device is accessed we need to determine which 89 89 + * pseudo-locked region it belongs to. This is done by matching the minor 90 90 + * number of the device to the pseudo-locked region it belongs. 91 91 + * 92 92 + * Minor numbers are assigned at the time a pseudo-locked region is associated 93 93 + * with a cache instance. 94 94 + * 95 95 + * Return: On success return pointer to resource group owning the pseudo-locked 96 96 + * region, NULL on failure. 97 97 + */ 98 98 + static struct rdtgroup *region_find_by_minor(unsigned int minor) 99 99 + { 100 100 + struct rdtgroup *rdtgrp, *rdtgrp_match = NULL; 101 101 + 102 102 + list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 103 103 + if (rdtgrp->plr && rdtgrp->plr->minor == minor) { 104 104 + rdtgrp_match = rdtgrp; 105 105 + break; 106 106 + } 107 107 + } 108 108 + return rdtgrp_match; 109 109 + } 110 110 + 111 111 + /** 112 112 + * struct pseudo_lock_pm_req - A power management QoS request list entry 113 113 + * @list: Entry within the @pm_reqs list for a pseudo-locked region 114 114 + * @req: PM QoS request 115 115 + */ 116 116 + struct pseudo_lock_pm_req { 117 117 + struct list_head list; 118 118 + struct dev_pm_qos_request req; 119 119 + }; 120 120 + 121 121 + static void pseudo_lock_cstates_relax(struct pseudo_lock_region *plr) 122 122 + { 123 123 + struct pseudo_lock_pm_req *pm_req, *next; 124 124 + 125 125 + list_for_each_entry_safe(pm_req, next, &plr->pm_reqs, list) { 126 126 + dev_pm_qos_remove_request(&pm_req->req); 127 127 + list_del(&pm_req->list); 128 128 + kfree(pm_req); 129 129 + } 130 130 + } 131 131 + 132 132 + /** 133 133 + * pseudo_lock_cstates_constrain - Restrict cores from entering C6 134 134 + * @plr: Pseudo-locked region 135 135 + * 136 136 + * To prevent the cache from being affected by power management entering 137 137 + * C6 has to be avoided. This is accomplished by requesting a latency 138 138 + * requirement lower than lowest C6 exit latency of all supported 139 139 + * platforms as found in the cpuidle state tables in the intel_idle driver. 140 140 + * At this time it is possible to do so with a single latency requirement 141 141 + * for all supported platforms. 142 142 + * 143 143 + * Since Goldmont is supported, which is affected by X86_BUG_MONITOR, 144 144 + * the ACPI latencies need to be considered while keeping in mind that C2 145 145 + * may be set to map to deeper sleep states. In this case the latency 146 146 + * requirement needs to prevent entering C2 also. 147 147 + * 148 148 + * Return: 0 on success, <0 on failure 149 149 + */ 150 150 + static int pseudo_lock_cstates_constrain(struct pseudo_lock_region *plr) 151 151 + { 152 152 + struct pseudo_lock_pm_req *pm_req; 153 153 + int cpu; 154 154 + int ret; 155 155 + 156 156 + for_each_cpu(cpu, &plr->d->hdr.cpu_mask) { 157 157 + pm_req = kzalloc(sizeof(*pm_req), GFP_KERNEL); 158 158 + if (!pm_req) { 159 159 + rdt_last_cmd_puts("Failure to allocate memory for PM QoS\n"); 160 160 + ret = -ENOMEM; 161 161 + goto out_err; 162 162 + } 163 163 + ret = dev_pm_qos_add_request(get_cpu_device(cpu), 164 164 + &pm_req->req, 165 165 + DEV_PM_QOS_RESUME_LATENCY, 166 166 + 30); 167 167 + if (ret < 0) { 168 168 + rdt_last_cmd_printf("Failed to add latency req CPU%d\n", 169 169 + cpu); 170 170 + kfree(pm_req); 171 171 + ret = -1; 172 172 + goto out_err; 173 173 + } 174 174 + list_add(&pm_req->list, &plr->pm_reqs); 175 175 + } 176 176 + 177 177 + return 0; 178 178 + 179 179 + out_err: 180 180 + pseudo_lock_cstates_relax(plr); 181 181 + return ret; 182 182 + } 183 183 + 184 184 + /** 185 185 + * pseudo_lock_region_clear - Reset pseudo-lock region data 186 186 + * @plr: pseudo-lock region 187 187 + * 188 188 + * All content of the pseudo-locked region is reset - any memory allocated 189 189 + * freed. 190 190 + * 191 191 + * Return: void 192 192 + */ 193 193 + static void pseudo_lock_region_clear(struct pseudo_lock_region *plr) 194 194 + { 195 195 + plr->size = 0; 196 196 + plr->line_size = 0; 197 197 + kfree(plr->kmem); 198 198 + plr->kmem = NULL; 199 199 + plr->s = NULL; 200 200 + if (plr->d) 201 201 + plr->d->plr = NULL; 202 202 + plr->d = NULL; 203 203 + plr->cbm = 0; 204 204 + plr->debugfs_dir = NULL; 205 205 + } 206 206 + 207 207 + /** 208 208 + * pseudo_lock_region_init - Initialize pseudo-lock region information 209 209 + * @plr: pseudo-lock region 210 210 + * 211 211 + * Called after user provided a schemata to be pseudo-locked. From the 212 212 + * schemata the &struct pseudo_lock_region is on entry already initialized 213 213 + * with the resource, domain, and capacity bitmask. Here the information 214 214 + * required for pseudo-locking is deduced from this data and &struct 215 215 + * pseudo_lock_region initialized further. This information includes: 216 216 + * - size in bytes of the region to be pseudo-locked 217 217 + * - cache line size to know the stride with which data needs to be accessed 218 218 + * to be pseudo-locked 219 219 + * - a cpu associated with the cache instance on which the pseudo-locking 220 220 + * flow can be executed 221 221 + * 222 222 + * Return: 0 on success, <0 on failure. Descriptive error will be written 223 223 + * to last_cmd_status buffer. 224 224 + */ 225 225 + static int pseudo_lock_region_init(struct pseudo_lock_region *plr) 226 226 + { 227 227 + enum resctrl_scope scope = plr->s->res->ctrl_scope; 228 228 + struct cacheinfo *ci; 229 229 + int ret; 230 230 + 231 231 + if (WARN_ON_ONCE(scope != RESCTRL_L2_CACHE && scope != RESCTRL_L3_CACHE)) 232 232 + return -ENODEV; 233 233 + 234 234 + /* Pick the first cpu we find that is associated with the cache. */ 235 235 + plr->cpu = cpumask_first(&plr->d->hdr.cpu_mask); 236 236 + 237 237 + if (!cpu_online(plr->cpu)) { 238 238 + rdt_last_cmd_printf("CPU %u associated with cache not online\n", 239 239 + plr->cpu); 240 240 + ret = -ENODEV; 241 241 + goto out_region; 242 242 + } 243 243 + 244 244 + ci = get_cpu_cacheinfo_level(plr->cpu, scope); 245 245 + if (ci) { 246 246 + plr->line_size = ci->coherency_line_size; 247 247 + plr->size = rdtgroup_cbm_to_size(plr->s->res, plr->d, plr->cbm); 248 248 + return 0; 249 249 + } 250 250 + 251 251 + ret = -1; 252 252 + rdt_last_cmd_puts("Unable to determine cache line size\n"); 253 253 + out_region: 254 254 + pseudo_lock_region_clear(plr); 255 255 + return ret; 256 256 + } 257 257 + 258 258 + /** 259 259 + * pseudo_lock_init - Initialize a pseudo-lock region 260 260 + * @rdtgrp: resource group to which new pseudo-locked region will belong 261 261 + * 262 262 + * A pseudo-locked region is associated with a resource group. When this 263 263 + * association is created the pseudo-locked region is initialized. The 264 264 + * details of the pseudo-locked region are not known at this time so only 265 265 + * allocation is done and association established. 266 266 + * 267 267 + * Return: 0 on success, <0 on failure 268 268 + */ 269 269 + static int pseudo_lock_init(struct rdtgroup *rdtgrp) 270 270 + { 271 271 + struct pseudo_lock_region *plr; 272 272 + 273 273 + plr = kzalloc(sizeof(*plr), GFP_KERNEL); 274 274 + if (!plr) 275 275 + return -ENOMEM; 276 276 + 277 277 + init_waitqueue_head(&plr->lock_thread_wq); 278 278 + INIT_LIST_HEAD(&plr->pm_reqs); 279 279 + rdtgrp->plr = plr; 280 280 + return 0; 281 281 + } 282 282 + 283 283 + /** 284 284 + * pseudo_lock_region_alloc - Allocate kernel memory that will be pseudo-locked 285 285 + * @plr: pseudo-lock region 286 286 + * 287 287 + * Initialize the details required to set up the pseudo-locked region and 288 288 + * allocate the contiguous memory that will be pseudo-locked to the cache. 289 289 + * 290 290 + * Return: 0 on success, <0 on failure. Descriptive error will be written 291 291 + * to last_cmd_status buffer. 292 292 + */ 293 293 + static int pseudo_lock_region_alloc(struct pseudo_lock_region *plr) 294 294 + { 295 295 + int ret; 296 296 + 297 297 + ret = pseudo_lock_region_init(plr); 298 298 + if (ret < 0) 299 299 + return ret; 300 300 + 301 301 + /* 302 302 + * We do not yet support contiguous regions larger than 303 303 + * KMALLOC_MAX_SIZE. 304 304 + */ 305 305 + if (plr->size > KMALLOC_MAX_SIZE) { 306 306 + rdt_last_cmd_puts("Requested region exceeds maximum size\n"); 307 307 + ret = -E2BIG; 308 308 + goto out_region; 309 309 + } 310 310 + 311 311 + plr->kmem = kzalloc(plr->size, GFP_KERNEL); 312 312 + if (!plr->kmem) { 313 313 + rdt_last_cmd_puts("Unable to allocate memory\n"); 314 314 + ret = -ENOMEM; 315 315 + goto out_region; 316 316 + } 317 317 + 318 318 + ret = 0; 319 319 + goto out; 320 320 + out_region: 321 321 + pseudo_lock_region_clear(plr); 322 322 + out: 323 323 + return ret; 324 324 + } 325 325 + 326 326 + /** 327 327 + * pseudo_lock_free - Free a pseudo-locked region 328 328 + * @rdtgrp: resource group to which pseudo-locked region belonged 329 329 + * 330 330 + * The pseudo-locked region's resources have already been released, or not 331 331 + * yet created at this point. Now it can be freed and disassociated from the 332 332 + * resource group. 333 333 + * 334 334 + * Return: void 335 335 + */ 336 336 + static void pseudo_lock_free(struct rdtgroup *rdtgrp) 337 337 + { 338 338 + pseudo_lock_region_clear(rdtgrp->plr); 339 339 + kfree(rdtgrp->plr); 340 340 + rdtgrp->plr = NULL; 341 341 + } 342 342 + 343 343 + /** 344 344 + * rdtgroup_monitor_in_progress - Test if monitoring in progress 345 345 + * @rdtgrp: resource group being queried 346 346 + * 347 347 + * Return: 1 if monitor groups have been created for this resource 348 348 + * group, 0 otherwise. 349 349 + */ 350 350 + static int rdtgroup_monitor_in_progress(struct rdtgroup *rdtgrp) 351 351 + { 352 352 + return !list_empty(&rdtgrp->mon.crdtgrp_list); 353 353 + } 354 354 + 355 355 + /** 356 356 + * rdtgroup_locksetup_user_restrict - Restrict user access to group 357 357 + * @rdtgrp: resource group needing access restricted 358 358 + * 359 359 + * A resource group used for cache pseudo-locking cannot have cpus or tasks 360 360 + * assigned to it. This is communicated to the user by restricting access 361 361 + * to all the files that can be used to make such changes. 362 362 + * 363 363 + * Permissions restored with rdtgroup_locksetup_user_restore() 364 364 + * 365 365 + * Return: 0 on success, <0 on failure. If a failure occurs during the 366 366 + * restriction of access an attempt will be made to restore permissions but 367 367 + * the state of the mode of these files will be uncertain when a failure 368 368 + * occurs. 369 369 + */ 370 370 + static int rdtgroup_locksetup_user_restrict(struct rdtgroup *rdtgrp) 371 371 + { 372 372 + int ret; 373 373 + 374 374 + ret = rdtgroup_kn_mode_restrict(rdtgrp, "tasks"); 375 375 + if (ret) 376 376 + return ret; 377 377 + 378 378 + ret = rdtgroup_kn_mode_restrict(rdtgrp, "cpus"); 379 379 + if (ret) 380 380 + goto err_tasks; 381 381 + 382 382 + ret = rdtgroup_kn_mode_restrict(rdtgrp, "cpus_list"); 383 383 + if (ret) 384 384 + goto err_cpus; 385 385 + 386 386 + if (resctrl_arch_mon_capable()) { 387 387 + ret = rdtgroup_kn_mode_restrict(rdtgrp, "mon_groups"); 388 388 + if (ret) 389 389 + goto err_cpus_list; 390 390 + } 391 391 + 392 392 + ret = 0; 393 393 + goto out; 394 394 + 395 395 + err_cpus_list: 396 396 + rdtgroup_kn_mode_restore(rdtgrp, "cpus_list", 0777); 397 397 + err_cpus: 398 398 + rdtgroup_kn_mode_restore(rdtgrp, "cpus", 0777); 399 399 + err_tasks: 400 400 + rdtgroup_kn_mode_restore(rdtgrp, "tasks", 0777); 401 401 + out: 402 402 + return ret; 403 403 + } 404 404 + 405 405 + /** 406 406 + * rdtgroup_locksetup_user_restore - Restore user access to group 407 407 + * @rdtgrp: resource group needing access restored 408 408 + * 409 409 + * Restore all file access previously removed using 410 410 + * rdtgroup_locksetup_user_restrict() 411 411 + * 412 412 + * Return: 0 on success, <0 on failure. If a failure occurs during the 413 413 + * restoration of access an attempt will be made to restrict permissions 414 414 + * again but the state of the mode of these files will be uncertain when 415 415 + * a failure occurs. 416 416 + */ 417 417 + static int rdtgroup_locksetup_user_restore(struct rdtgroup *rdtgrp) 418 418 + { 419 419 + int ret; 420 420 + 421 421 + ret = rdtgroup_kn_mode_restore(rdtgrp, "tasks", 0777); 422 422 + if (ret) 423 423 + return ret; 424 424 + 425 425 + ret = rdtgroup_kn_mode_restore(rdtgrp, "cpus", 0777); 426 426 + if (ret) 427 427 + goto err_tasks; 428 428 + 429 429 + ret = rdtgroup_kn_mode_restore(rdtgrp, "cpus_list", 0777); 430 430 + if (ret) 431 431 + goto err_cpus; 432 432 + 433 433 + if (resctrl_arch_mon_capable()) { 434 434 + ret = rdtgroup_kn_mode_restore(rdtgrp, "mon_groups", 0777); 435 435 + if (ret) 436 436 + goto err_cpus_list; 437 437 + } 438 438 + 439 439 + ret = 0; 440 440 + goto out; 441 441 + 442 442 + err_cpus_list: 443 443 + rdtgroup_kn_mode_restrict(rdtgrp, "cpus_list"); 444 444 + err_cpus: 445 445 + rdtgroup_kn_mode_restrict(rdtgrp, "cpus"); 446 446 + err_tasks: 447 447 + rdtgroup_kn_mode_restrict(rdtgrp, "tasks"); 448 448 + out: 449 449 + return ret; 450 450 + } 451 451 + 452 452 + /** 453 453 + * rdtgroup_locksetup_enter - Resource group enters locksetup mode 454 454 + * @rdtgrp: resource group requested to enter locksetup mode 455 455 + * 456 456 + * A resource group enters locksetup mode to reflect that it would be used 457 457 + * to represent a pseudo-locked region and is in the process of being set 458 458 + * up to do so. A resource group used for a pseudo-locked region would 459 459 + * lose the closid associated with it so we cannot allow it to have any 460 460 + * tasks or cpus assigned nor permit tasks or cpus to be assigned in the 461 461 + * future. Monitoring of a pseudo-locked region is not allowed either. 462 462 + * 463 463 + * The above and more restrictions on a pseudo-locked region are checked 464 464 + * for and enforced before the resource group enters the locksetup mode. 465 465 + * 466 466 + * Returns: 0 if the resource group successfully entered locksetup mode, <0 467 467 + * on failure. On failure the last_cmd_status buffer is updated with text to 468 468 + * communicate details of failure to the user. 469 469 + */ 470 470 + int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp) 471 471 + { 472 472 + int ret; 473 473 + 474 474 + /* 475 475 + * The default resource group can neither be removed nor lose the 476 476 + * default closid associated with it. 477 477 + */ 478 478 + if (rdtgrp == &rdtgroup_default) { 479 479 + rdt_last_cmd_puts("Cannot pseudo-lock default group\n"); 480 480 + return -EINVAL; 481 481 + } 482 482 + 483 483 + /* 484 484 + * Cache Pseudo-locking not supported when CDP is enabled. 485 485 + * 486 486 + * Some things to consider if you would like to enable this 487 487 + * support (using L3 CDP as example): 488 488 + * - When CDP is enabled two separate resources are exposed, 489 489 + * L3DATA and L3CODE, but they are actually on the same cache. 490 490 + * The implication for pseudo-locking is that if a 491 491 + * pseudo-locked region is created on a domain of one 492 492 + * resource (eg. L3CODE), then a pseudo-locked region cannot 493 493 + * be created on that same domain of the other resource 494 494 + * (eg. L3DATA). This is because the creation of a 495 495 + * pseudo-locked region involves a call to wbinvd that will 496 496 + * affect all cache allocations on particular domain. 497 497 + * - Considering the previous, it may be possible to only 498 498 + * expose one of the CDP resources to pseudo-locking and 499 499 + * hide the other. For example, we could consider to only 500 500 + * expose L3DATA and since the L3 cache is unified it is 501 501 + * still possible to place instructions there are execute it. 502 502 + * - If only one region is exposed to pseudo-locking we should 503 503 + * still keep in mind that availability of a portion of cache 504 504 + * for pseudo-locking should take into account both resources. 505 505 + * Similarly, if a pseudo-locked region is created in one 506 506 + * resource, the portion of cache used by it should be made 507 507 + * unavailable to all future allocations from both resources. 508 508 + */ 509 509 + if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3) || 510 510 + resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) { 511 511 + rdt_last_cmd_puts("CDP enabled\n"); 512 512 + return -EINVAL; 513 513 + } 514 514 + 515 515 + /* 516 516 + * Not knowing the bits to disable prefetching implies that this 517 517 + * platform does not support Cache Pseudo-Locking. 518 518 + */ 519 519 + if (resctrl_arch_get_prefetch_disable_bits() == 0) { 520 520 + rdt_last_cmd_puts("Pseudo-locking not supported\n"); 521 521 + return -EINVAL; 522 522 + } 523 523 + 524 524 + if (rdtgroup_monitor_in_progress(rdtgrp)) { 525 525 + rdt_last_cmd_puts("Monitoring in progress\n"); 526 526 + return -EINVAL; 527 527 + } 528 528 + 529 529 + if (rdtgroup_tasks_assigned(rdtgrp)) { 530 530 + rdt_last_cmd_puts("Tasks assigned to resource group\n"); 531 531 + return -EINVAL; 532 532 + } 533 533 + 534 534 + if (!cpumask_empty(&rdtgrp->cpu_mask)) { 535 535 + rdt_last_cmd_puts("CPUs assigned to resource group\n"); 536 536 + return -EINVAL; 537 537 + } 538 538 + 539 539 + if (rdtgroup_locksetup_user_restrict(rdtgrp)) { 540 540 + rdt_last_cmd_puts("Unable to modify resctrl permissions\n"); 541 541 + return -EIO; 542 542 + } 543 543 + 544 544 + ret = pseudo_lock_init(rdtgrp); 545 545 + if (ret) { 546 546 + rdt_last_cmd_puts("Unable to init pseudo-lock region\n"); 547 547 + goto out_release; 548 548 + } 549 549 + 550 550 + /* 551 551 + * If this system is capable of monitoring a rmid would have been 552 552 + * allocated when the control group was created. This is not needed 553 553 + * anymore when this group would be used for pseudo-locking. This 554 554 + * is safe to call on platforms not capable of monitoring. 555 555 + */ 556 556 + free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 557 557 + 558 558 + ret = 0; 559 559 + goto out; 560 560 + 561 561 + out_release: 562 562 + rdtgroup_locksetup_user_restore(rdtgrp); 563 563 + out: 564 564 + return ret; 565 565 + } 566 566 + 567 567 + /** 568 568 + * rdtgroup_locksetup_exit - resource group exist locksetup mode 569 569 + * @rdtgrp: resource group 570 570 + * 571 571 + * When a resource group exits locksetup mode the earlier restrictions are 572 572 + * lifted. 573 573 + * 574 574 + * Return: 0 on success, <0 on failure 575 575 + */ 576 576 + int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp) 577 577 + { 578 578 + int ret; 579 579 + 580 580 + if (resctrl_arch_mon_capable()) { 581 581 + ret = alloc_rmid(rdtgrp->closid); 582 582 + if (ret < 0) { 583 583 + rdt_last_cmd_puts("Out of RMIDs\n"); 584 584 + return ret; 585 585 + } 586 586 + rdtgrp->mon.rmid = ret; 587 587 + } 588 588 + 589 589 + ret = rdtgroup_locksetup_user_restore(rdtgrp); 590 590 + if (ret) { 591 591 + free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 592 592 + return ret; 593 593 + } 594 594 + 595 595 + pseudo_lock_free(rdtgrp); 596 596 + return 0; 597 597 + } 598 598 + 599 599 + /** 600 600 + * rdtgroup_cbm_overlaps_pseudo_locked - Test if CBM or portion is pseudo-locked 601 601 + * @d: RDT domain 602 602 + * @cbm: CBM to test 603 603 + * 604 604 + * @d represents a cache instance and @cbm a capacity bitmask that is 605 605 + * considered for it. Determine if @cbm overlaps with any existing 606 606 + * pseudo-locked region on @d. 607 607 + * 608 608 + * @cbm is unsigned long, even if only 32 bits are used, to make the 609 609 + * bitmap functions work correctly. 610 610 + * 611 611 + * Return: true if @cbm overlaps with pseudo-locked region on @d, false 612 612 + * otherwise. 613 613 + */ 614 614 + bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_ctrl_domain *d, unsigned long cbm) 615 615 + { 616 616 + unsigned int cbm_len; 617 617 + unsigned long cbm_b; 618 618 + 619 619 + if (d->plr) { 620 620 + cbm_len = d->plr->s->res->cache.cbm_len; 621 621 + cbm_b = d->plr->cbm; 622 622 + if (bitmap_intersects(&cbm, &cbm_b, cbm_len)) 623 623 + return true; 624 624 + } 625 625 + return false; 626 626 + } 627 627 + 628 628 + /** 629 629 + * rdtgroup_pseudo_locked_in_hierarchy - Pseudo-locked region in cache hierarchy 630 630 + * @d: RDT domain under test 631 631 + * 632 632 + * The setup of a pseudo-locked region affects all cache instances within 633 633 + * the hierarchy of the region. It is thus essential to know if any 634 634 + * pseudo-locked regions exist within a cache hierarchy to prevent any 635 635 + * attempts to create new pseudo-locked regions in the same hierarchy. 636 636 + * 637 637 + * Return: true if a pseudo-locked region exists in the hierarchy of @d or 638 638 + * if it is not possible to test due to memory allocation issue, 639 639 + * false otherwise. 640 640 + */ 641 641 + bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_ctrl_domain *d) 642 642 + { 643 643 + struct rdt_ctrl_domain *d_i; 644 644 + cpumask_var_t cpu_with_psl; 645 645 + struct rdt_resource *r; 646 646 + bool ret = false; 647 647 + 648 648 + /* Walking r->domains, ensure it can't race with cpuhp */ 649 649 + lockdep_assert_cpus_held(); 650 650 + 651 651 + if (!zalloc_cpumask_var(&cpu_with_psl, GFP_KERNEL)) 652 652 + return true; 653 653 + 654 654 + /* 655 655 + * First determine which cpus have pseudo-locked regions 656 656 + * associated with them. 657 657 + */ 658 658 + for_each_alloc_capable_rdt_resource(r) { 659 659 + list_for_each_entry(d_i, &r->ctrl_domains, hdr.list) { 660 660 + if (d_i->plr) 661 661 + cpumask_or(cpu_with_psl, cpu_with_psl, 662 662 + &d_i->hdr.cpu_mask); 663 663 + } 664 664 + } 665 665 + 666 666 + /* 667 667 + * Next test if new pseudo-locked region would intersect with 668 668 + * existing region. 669 669 + */ 670 670 + if (cpumask_intersects(&d->hdr.cpu_mask, cpu_with_psl)) 671 671 + ret = true; 672 672 + 673 673 + free_cpumask_var(cpu_with_psl); 674 674 + return ret; 675 675 + } 676 676 + 677 677 + /** 678 678 + * pseudo_lock_measure_cycles - Trigger latency measure to pseudo-locked region 679 679 + * @rdtgrp: Resource group to which the pseudo-locked region belongs. 680 680 + * @sel: Selector of which measurement to perform on a pseudo-locked region. 681 681 + * 682 682 + * The measurement of latency to access a pseudo-locked region should be 683 683 + * done from a cpu that is associated with that pseudo-locked region. 684 684 + * Determine which cpu is associated with this region and start a thread on 685 685 + * that cpu to perform the measurement, wait for that thread to complete. 686 686 + * 687 687 + * Return: 0 on success, <0 on failure 688 688 + */ 689 689 + static int pseudo_lock_measure_cycles(struct rdtgroup *rdtgrp, int sel) 690 690 + { 691 691 + struct pseudo_lock_region *plr = rdtgrp->plr; 692 692 + struct task_struct *thread; 693 693 + unsigned int cpu; 694 694 + int ret = -1; 695 695 + 696 696 + cpus_read_lock(); 697 697 + mutex_lock(&rdtgroup_mutex); 698 698 + 699 699 + if (rdtgrp->flags & RDT_DELETED) { 700 700 + ret = -ENODEV; 701 701 + goto out; 702 702 + } 703 703 + 704 704 + if (!plr->d) { 705 705 + ret = -ENODEV; 706 706 + goto out; 707 707 + } 708 708 + 709 709 + plr->thread_done = 0; 710 710 + cpu = cpumask_first(&plr->d->hdr.cpu_mask); 711 711 + if (!cpu_online(cpu)) { 712 712 + ret = -ENODEV; 713 713 + goto out; 714 714 + } 715 715 + 716 716 + plr->cpu = cpu; 717 717 + 718 718 + if (sel == 1) 719 719 + thread = kthread_run_on_cpu(resctrl_arch_measure_cycles_lat_fn, 720 720 + plr, cpu, "pseudo_lock_measure/%u"); 721 721 + else if (sel == 2) 722 722 + thread = kthread_run_on_cpu(resctrl_arch_measure_l2_residency, 723 723 + plr, cpu, "pseudo_lock_measure/%u"); 724 724 + else if (sel == 3) 725 725 + thread = kthread_run_on_cpu(resctrl_arch_measure_l3_residency, 726 726 + plr, cpu, "pseudo_lock_measure/%u"); 727 727 + else 728 728 + goto out; 729 729 + 730 730 + if (IS_ERR(thread)) { 731 731 + ret = PTR_ERR(thread); 732 732 + goto out; 733 733 + } 734 734 + 735 735 + ret = wait_event_interruptible(plr->lock_thread_wq, 736 736 + plr->thread_done == 1); 737 737 + if (ret < 0) 738 738 + goto out; 739 739 + 740 740 + ret = 0; 741 741 + 742 742 + out: 743 743 + mutex_unlock(&rdtgroup_mutex); 744 744 + cpus_read_unlock(); 745 745 + return ret; 746 746 + } 747 747 + 748 748 + static ssize_t pseudo_lock_measure_trigger(struct file *file, 749 749 + const char __user *user_buf, 750 750 + size_t count, loff_t *ppos) 751 751 + { 752 752 + struct rdtgroup *rdtgrp = file->private_data; 753 753 + size_t buf_size; 754 754 + char buf[32]; 755 755 + int ret; 756 756 + int sel; 757 757 + 758 758 + buf_size = min(count, (sizeof(buf) - 1)); 759 759 + if (copy_from_user(buf, user_buf, buf_size)) 760 760 + return -EFAULT; 761 761 + 762 762 + buf[buf_size] = '\0'; 763 763 + ret = kstrtoint(buf, 10, &sel); 764 764 + if (ret == 0) { 765 765 + if (sel != 1 && sel != 2 && sel != 3) 766 766 + return -EINVAL; 767 767 + ret = debugfs_file_get(file->f_path.dentry); 768 768 + if (ret) 769 769 + return ret; 770 770 + ret = pseudo_lock_measure_cycles(rdtgrp, sel); 771 771 + if (ret == 0) 772 772 + ret = count; 773 773 + debugfs_file_put(file->f_path.dentry); 774 774 + } 775 775 + 776 776 + return ret; 777 777 + } 778 778 + 779 779 + static const struct file_operations pseudo_measure_fops = { 780 780 + .write = pseudo_lock_measure_trigger, 781 781 + .open = simple_open, 782 782 + .llseek = default_llseek, 783 783 + }; 784 784 + 785 785 + /** 786 786 + * rdtgroup_pseudo_lock_create - Create a pseudo-locked region 787 787 + * @rdtgrp: resource group to which pseudo-lock region belongs 788 788 + * 789 789 + * Called when a resource group in the pseudo-locksetup mode receives a 790 790 + * valid schemata that should be pseudo-locked. Since the resource group is 791 791 + * in pseudo-locksetup mode the &struct pseudo_lock_region has already been 792 792 + * allocated and initialized with the essential information. If a failure 793 793 + * occurs the resource group remains in the pseudo-locksetup mode with the 794 794 + * &struct pseudo_lock_region associated with it, but cleared from all 795 795 + * information and ready for the user to re-attempt pseudo-locking by 796 796 + * writing the schemata again. 797 797 + * 798 798 + * Return: 0 if the pseudo-locked region was successfully pseudo-locked, <0 799 799 + * on failure. Descriptive error will be written to last_cmd_status buffer. 800 800 + */ 801 801 + int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp) 802 802 + { 803 803 + struct pseudo_lock_region *plr = rdtgrp->plr; 804 804 + struct task_struct *thread; 805 805 + unsigned int new_minor; 806 806 + struct device *dev; 807 807 + char *kn_name __free(kfree) = NULL; 808 808 + int ret; 809 809 + 810 810 + ret = pseudo_lock_region_alloc(plr); 811 811 + if (ret < 0) 812 812 + return ret; 813 813 + 814 814 + ret = pseudo_lock_cstates_constrain(plr); 815 815 + if (ret < 0) { 816 816 + ret = -EINVAL; 817 817 + goto out_region; 818 818 + } 819 819 + kn_name = kstrdup(rdt_kn_name(rdtgrp->kn), GFP_KERNEL); 820 820 + if (!kn_name) { 821 821 + ret = -ENOMEM; 822 822 + goto out_cstates; 823 823 + } 824 824 + 825 825 + plr->thread_done = 0; 826 826 + 827 827 + thread = kthread_run_on_cpu(resctrl_arch_pseudo_lock_fn, plr, 828 828 + plr->cpu, "pseudo_lock/%u"); 829 829 + if (IS_ERR(thread)) { 830 830 + ret = PTR_ERR(thread); 831 831 + rdt_last_cmd_printf("Locking thread returned error %d\n", ret); 832 832 + goto out_cstates; 833 833 + } 834 834 + 835 835 + ret = wait_event_interruptible(plr->lock_thread_wq, 836 836 + plr->thread_done == 1); 837 837 + if (ret < 0) { 838 838 + /* 839 839 + * If the thread does not get on the CPU for whatever 840 840 + * reason and the process which sets up the region is 841 841 + * interrupted then this will leave the thread in runnable 842 842 + * state and once it gets on the CPU it will dereference 843 843 + * the cleared, but not freed, plr struct resulting in an 844 844 + * empty pseudo-locking loop. 845 845 + */ 846 846 + rdt_last_cmd_puts("Locking thread interrupted\n"); 847 847 + goto out_cstates; 848 848 + } 849 849 + 850 850 + ret = pseudo_lock_minor_get(&new_minor); 851 851 + if (ret < 0) { 852 852 + rdt_last_cmd_puts("Unable to obtain a new minor number\n"); 853 853 + goto out_cstates; 854 854 + } 855 855 + 856 856 + /* 857 857 + * Unlock access but do not release the reference. The 858 858 + * pseudo-locked region will still be here on return. 859 859 + * 860 860 + * The mutex has to be released temporarily to avoid a potential 861 861 + * deadlock with the mm->mmap_lock which is obtained in the 862 862 + * device_create() and debugfs_create_dir() callpath below as well as 863 863 + * before the mmap() callback is called. 864 864 + */ 865 865 + mutex_unlock(&rdtgroup_mutex); 866 866 + 867 867 + if (!IS_ERR_OR_NULL(debugfs_resctrl)) { 868 868 + plr->debugfs_dir = debugfs_create_dir(kn_name, debugfs_resctrl); 869 869 + if (!IS_ERR_OR_NULL(plr->debugfs_dir)) 870 870 + debugfs_create_file("pseudo_lock_measure", 0200, 871 871 + plr->debugfs_dir, rdtgrp, 872 872 + &pseudo_measure_fops); 873 873 + } 874 874 + 875 875 + dev = device_create(&pseudo_lock_class, NULL, 876 876 + MKDEV(pseudo_lock_major, new_minor), 877 877 + rdtgrp, "%s", kn_name); 878 878 + 879 879 + mutex_lock(&rdtgroup_mutex); 880 880 + 881 881 + if (IS_ERR(dev)) { 882 882 + ret = PTR_ERR(dev); 883 883 + rdt_last_cmd_printf("Failed to create character device: %d\n", 884 884 + ret); 885 885 + goto out_debugfs; 886 886 + } 887 887 + 888 888 + /* We released the mutex - check if group was removed while we did so */ 889 889 + if (rdtgrp->flags & RDT_DELETED) { 890 890 + ret = -ENODEV; 891 891 + goto out_device; 892 892 + } 893 893 + 894 894 + plr->minor = new_minor; 895 895 + 896 896 + rdtgrp->mode = RDT_MODE_PSEUDO_LOCKED; 897 897 + closid_free(rdtgrp->closid); 898 898 + rdtgroup_kn_mode_restore(rdtgrp, "cpus", 0444); 899 899 + rdtgroup_kn_mode_restore(rdtgrp, "cpus_list", 0444); 900 900 + 901 901 + ret = 0; 902 902 + goto out; 903 903 + 904 904 + out_device: 905 905 + device_destroy(&pseudo_lock_class, MKDEV(pseudo_lock_major, new_minor)); 906 906 + out_debugfs: 907 907 + debugfs_remove_recursive(plr->debugfs_dir); 908 908 + pseudo_lock_minor_release(new_minor); 909 909 + out_cstates: 910 910 + pseudo_lock_cstates_relax(plr); 911 911 + out_region: 912 912 + pseudo_lock_region_clear(plr); 913 913 + out: 914 914 + return ret; 915 915 + } 916 916 + 917 917 + /** 918 918 + * rdtgroup_pseudo_lock_remove - Remove a pseudo-locked region 919 919 + * @rdtgrp: resource group to which the pseudo-locked region belongs 920 920 + * 921 921 + * The removal of a pseudo-locked region can be initiated when the resource 922 922 + * group is removed from user space via a "rmdir" from userspace or the 923 923 + * unmount of the resctrl filesystem. On removal the resource group does 924 924 + * not go back to pseudo-locksetup mode before it is removed, instead it is 925 925 + * removed directly. There is thus asymmetry with the creation where the 926 926 + * &struct pseudo_lock_region is removed here while it was not created in 927 927 + * rdtgroup_pseudo_lock_create(). 928 928 + * 929 929 + * Return: void 930 930 + */ 931 931 + void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp) 932 932 + { 933 933 + struct pseudo_lock_region *plr = rdtgrp->plr; 934 934 + 935 935 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 936 936 + /* 937 937 + * Default group cannot be a pseudo-locked region so we can 938 938 + * free closid here. 939 939 + */ 940 940 + closid_free(rdtgrp->closid); 941 941 + goto free; 942 942 + } 943 943 + 944 944 + pseudo_lock_cstates_relax(plr); 945 945 + debugfs_remove_recursive(rdtgrp->plr->debugfs_dir); 946 946 + device_destroy(&pseudo_lock_class, MKDEV(pseudo_lock_major, plr->minor)); 947 947 + pseudo_lock_minor_release(plr->minor); 948 948 + 949 949 + free: 950 950 + pseudo_lock_free(rdtgrp); 951 951 + } 952 952 + 953 953 + static int pseudo_lock_dev_open(struct inode *inode, struct file *filp) 954 954 + { 955 955 + struct rdtgroup *rdtgrp; 956 956 + 957 957 + mutex_lock(&rdtgroup_mutex); 958 958 + 959 959 + rdtgrp = region_find_by_minor(iminor(inode)); 960 960 + if (!rdtgrp) { 961 961 + mutex_unlock(&rdtgroup_mutex); 962 962 + return -ENODEV; 963 963 + } 964 964 + 965 965 + filp->private_data = rdtgrp; 966 966 + atomic_inc(&rdtgrp->waitcount); 967 967 + /* Perform a non-seekable open - llseek is not supported */ 968 968 + filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE); 969 969 + 970 970 + mutex_unlock(&rdtgroup_mutex); 971 971 + 972 972 + return 0; 973 973 + } 974 974 + 975 975 + static int pseudo_lock_dev_release(struct inode *inode, struct file *filp) 976 976 + { 977 977 + struct rdtgroup *rdtgrp; 978 978 + 979 979 + mutex_lock(&rdtgroup_mutex); 980 980 + rdtgrp = filp->private_data; 981 981 + WARN_ON(!rdtgrp); 982 982 + if (!rdtgrp) { 983 983 + mutex_unlock(&rdtgroup_mutex); 984 984 + return -ENODEV; 985 985 + } 986 986 + filp->private_data = NULL; 987 987 + atomic_dec(&rdtgrp->waitcount); 988 988 + mutex_unlock(&rdtgroup_mutex); 989 989 + return 0; 990 990 + } 991 991 + 992 992 + static int pseudo_lock_dev_mremap(struct vm_area_struct *area) 993 993 + { 994 994 + /* Not supported */ 995 995 + return -EINVAL; 996 996 + } 997 997 + 998 998 + static const struct vm_operations_struct pseudo_mmap_ops = { 999 999 + .mremap = pseudo_lock_dev_mremap, 1000 1000 + }; 1001 1001 + 1002 1002 + static int pseudo_lock_dev_mmap(struct file *filp, struct vm_area_struct *vma) 1003 1003 + { 1004 1004 + unsigned long vsize = vma->vm_end - vma->vm_start; 1005 1005 + unsigned long off = vma->vm_pgoff << PAGE_SHIFT; 1006 1006 + struct pseudo_lock_region *plr; 1007 1007 + struct rdtgroup *rdtgrp; 1008 1008 + unsigned long physical; 1009 1009 + unsigned long psize; 1010 1010 + 1011 1011 + mutex_lock(&rdtgroup_mutex); 1012 1012 + 1013 1013 + rdtgrp = filp->private_data; 1014 1014 + WARN_ON(!rdtgrp); 1015 1015 + if (!rdtgrp) { 1016 1016 + mutex_unlock(&rdtgroup_mutex); 1017 1017 + return -ENODEV; 1018 1018 + } 1019 1019 + 1020 1020 + plr = rdtgrp->plr; 1021 1021 + 1022 1022 + if (!plr->d) { 1023 1023 + mutex_unlock(&rdtgroup_mutex); 1024 1024 + return -ENODEV; 1025 1025 + } 1026 1026 + 1027 1027 + /* 1028 1028 + * Task is required to run with affinity to the cpus associated 1029 1029 + * with the pseudo-locked region. If this is not the case the task 1030 1030 + * may be scheduled elsewhere and invalidate entries in the 1031 1031 + * pseudo-locked region. 1032 1032 + */ 1033 1033 + if (!cpumask_subset(current->cpus_ptr, &plr->d->hdr.cpu_mask)) { 1034 1034 + mutex_unlock(&rdtgroup_mutex); 1035 1035 + return -EINVAL; 1036 1036 + } 1037 1037 + 1038 1038 + physical = __pa(plr->kmem) >> PAGE_SHIFT; 1039 1039 + psize = plr->size - off; 1040 1040 + 1041 1041 + if (off > plr->size) { 1042 1042 + mutex_unlock(&rdtgroup_mutex); 1043 1043 + return -ENOSPC; 1044 1044 + } 1045 1045 + 1046 1046 + /* 1047 1047 + * Ensure changes are carried directly to the memory being mapped, 1048 1048 + * do not allow copy-on-write mapping. 1049 1049 + */ 1050 1050 + if (!(vma->vm_flags & VM_SHARED)) { 1051 1051 + mutex_unlock(&rdtgroup_mutex); 1052 1052 + return -EINVAL; 1053 1053 + } 1054 1054 + 1055 1055 + if (vsize > psize) { 1056 1056 + mutex_unlock(&rdtgroup_mutex); 1057 1057 + return -ENOSPC; 1058 1058 + } 1059 1059 + 1060 1060 + memset(plr->kmem + off, 0, vsize); 1061 1061 + 1062 1062 + if (remap_pfn_range(vma, vma->vm_start, physical + vma->vm_pgoff, 1063 1063 + vsize, vma->vm_page_prot)) { 1064 1064 + mutex_unlock(&rdtgroup_mutex); 1065 1065 + return -EAGAIN; 1066 1066 + } 1067 1067 + vma->vm_ops = &pseudo_mmap_ops; 1068 1068 + mutex_unlock(&rdtgroup_mutex); 1069 1069 + return 0; 1070 1070 + } 1071 1071 + 1072 1072 + static const struct file_operations pseudo_lock_dev_fops = { 1073 1073 + .owner = THIS_MODULE, 1074 1074 + .read = NULL, 1075 1075 + .write = NULL, 1076 1076 + .open = pseudo_lock_dev_open, 1077 1077 + .release = pseudo_lock_dev_release, 1078 1078 + .mmap = pseudo_lock_dev_mmap, 1079 1079 + }; 1080 1080 + 1081 1081 + int rdt_pseudo_lock_init(void) 1082 1082 + { 1083 1083 + int ret; 1084 1084 + 1085 1085 + ret = register_chrdev(0, "pseudo_lock", &pseudo_lock_dev_fops); 1086 1086 + if (ret < 0) 1087 1087 + return ret; 1088 1088 + 1089 1089 + pseudo_lock_major = ret; 1090 1090 + 1091 1091 + ret = class_register(&pseudo_lock_class); 1092 1092 + if (ret) { 1093 1093 + unregister_chrdev(pseudo_lock_major, "pseudo_lock"); 1094 1094 + return ret; 1095 1095 + } 1096 1096 + 1097 1097 + return 0; 1098 1098 + } 1099 1099 + 1100 1100 + void rdt_pseudo_lock_release(void) 1101 1101 + { 1102 1102 + class_unregister(&pseudo_lock_class); 1103 1103 + unregister_chrdev(pseudo_lock_major, "pseudo_lock"); 1104 1104 + pseudo_lock_major = 0; 1105 1105 + }

+4353

fs/resctrl/rdtgroup.c

reviewed

··· 1 1 + // SPDX-License-Identifier: GPL-2.0-only 2 2 + /* 3 3 + * User interface for Resource Allocation in Resource Director Technology(RDT) 4 4 + * 5 5 + * Copyright (C) 2016 Intel Corporation 6 6 + * 7 7 + * Author: Fenghua Yu <fenghua.yu@intel.com> 8 8 + * 9 9 + * More information about RDT be found in the Intel (R) x86 Architecture 10 10 + * Software Developer Manual. 11 11 + */ 12 12 + 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 15 15 + #include <linux/cpu.h> 16 16 + #include <linux/debugfs.h> 17 17 + #include <linux/fs.h> 18 18 + #include <linux/fs_parser.h> 19 19 + #include <linux/sysfs.h> 20 20 + #include <linux/kernfs.h> 21 21 + #include <linux/resctrl.h> 22 22 + #include <linux/seq_buf.h> 23 23 + #include <linux/seq_file.h> 24 24 + #include <linux/sched/task.h> 25 25 + #include <linux/slab.h> 26 26 + #include <linux/user_namespace.h> 27 27 + 28 28 + #include <uapi/linux/magic.h> 29 29 + 30 30 + #include "internal.h" 31 31 + 32 32 + /* Mutex to protect rdtgroup access. */ 33 33 + DEFINE_MUTEX(rdtgroup_mutex); 34 34 + 35 35 + static struct kernfs_root *rdt_root; 36 36 + 37 37 + struct rdtgroup rdtgroup_default; 38 38 + 39 39 + LIST_HEAD(rdt_all_groups); 40 40 + 41 41 + /* list of entries for the schemata file */ 42 42 + LIST_HEAD(resctrl_schema_all); 43 43 + 44 44 + /* 45 45 + * List of struct mon_data containing private data of event files for use by 46 46 + * rdtgroup_mondata_show(). Protected by rdtgroup_mutex. 47 47 + */ 48 48 + static LIST_HEAD(mon_data_kn_priv_list); 49 49 + 50 50 + /* The filesystem can only be mounted once. */ 51 51 + bool resctrl_mounted; 52 52 + 53 53 + /* Kernel fs node for "info" directory under root */ 54 54 + static struct kernfs_node *kn_info; 55 55 + 56 56 + /* Kernel fs node for "mon_groups" directory under root */ 57 57 + static struct kernfs_node *kn_mongrp; 58 58 + 59 59 + /* Kernel fs node for "mon_data" directory under root */ 60 60 + static struct kernfs_node *kn_mondata; 61 61 + 62 62 + /* 63 63 + * Used to store the max resource name width to display the schemata names in 64 64 + * a tabular format. 65 65 + */ 66 66 + int max_name_width; 67 67 + 68 68 + static struct seq_buf last_cmd_status; 69 69 + 70 70 + static char last_cmd_status_buf[512]; 71 71 + 72 72 + static int rdtgroup_setup_root(struct rdt_fs_context *ctx); 73 73 + 74 74 + static void rdtgroup_destroy_root(void); 75 75 + 76 76 + struct dentry *debugfs_resctrl; 77 77 + 78 78 + /* 79 79 + * Memory bandwidth monitoring event to use for the default CTRL_MON group 80 80 + * and each new CTRL_MON group created by the user. Only relevant when 81 81 + * the filesystem is mounted with the "mba_MBps" option so it does not 82 82 + * matter that it remains uninitialized on systems that do not support 83 83 + * the "mba_MBps" option. 84 84 + */ 85 85 + enum resctrl_event_id mba_mbps_default_event; 86 86 + 87 87 + static bool resctrl_debug; 88 88 + 89 89 + void rdt_last_cmd_clear(void) 90 90 + { 91 91 + lockdep_assert_held(&rdtgroup_mutex); 92 92 + seq_buf_clear(&last_cmd_status); 93 93 + } 94 94 + 95 95 + void rdt_last_cmd_puts(const char *s) 96 96 + { 97 97 + lockdep_assert_held(&rdtgroup_mutex); 98 98 + seq_buf_puts(&last_cmd_status, s); 99 99 + } 100 100 + 101 101 + void rdt_last_cmd_printf(const char *fmt, ...) 102 102 + { 103 103 + va_list ap; 104 104 + 105 105 + va_start(ap, fmt); 106 106 + lockdep_assert_held(&rdtgroup_mutex); 107 107 + seq_buf_vprintf(&last_cmd_status, fmt, ap); 108 108 + va_end(ap); 109 109 + } 110 110 + 111 111 + void rdt_staged_configs_clear(void) 112 112 + { 113 113 + struct rdt_ctrl_domain *dom; 114 114 + struct rdt_resource *r; 115 115 + 116 116 + lockdep_assert_held(&rdtgroup_mutex); 117 117 + 118 118 + for_each_alloc_capable_rdt_resource(r) { 119 119 + list_for_each_entry(dom, &r->ctrl_domains, hdr.list) 120 120 + memset(dom->staged_config, 0, sizeof(dom->staged_config)); 121 121 + } 122 122 + } 123 123 + 124 124 + static bool resctrl_is_mbm_enabled(void) 125 125 + { 126 126 + return (resctrl_arch_is_mbm_total_enabled() || 127 127 + resctrl_arch_is_mbm_local_enabled()); 128 128 + } 129 129 + 130 130 + static bool resctrl_is_mbm_event(int e) 131 131 + { 132 132 + return (e >= QOS_L3_MBM_TOTAL_EVENT_ID && 133 133 + e <= QOS_L3_MBM_LOCAL_EVENT_ID); 134 134 + } 135 135 + 136 136 + /* 137 137 + * Trivial allocator for CLOSIDs. Use BITMAP APIs to manipulate a bitmap 138 138 + * of free CLOSIDs. 139 139 + * 140 140 + * Using a global CLOSID across all resources has some advantages and 141 141 + * some drawbacks: 142 142 + * + We can simply set current's closid to assign a task to a resource 143 143 + * group. 144 144 + * + Context switch code can avoid extra memory references deciding which 145 145 + * CLOSID to load into the PQR_ASSOC MSR 146 146 + * - We give up some options in configuring resource groups across multi-socket 147 147 + * systems. 148 148 + * - Our choices on how to configure each resource become progressively more 149 149 + * limited as the number of resources grows. 150 150 + */ 151 151 + static unsigned long *closid_free_map; 152 152 + 153 153 + static int closid_free_map_len; 154 154 + 155 155 + int closids_supported(void) 156 156 + { 157 157 + return closid_free_map_len; 158 158 + } 159 159 + 160 160 + static int closid_init(void) 161 161 + { 162 162 + struct resctrl_schema *s; 163 163 + u32 rdt_min_closid = ~0; 164 164 + 165 165 + /* Monitor only platforms still call closid_init() */ 166 166 + if (list_empty(&resctrl_schema_all)) 167 167 + return 0; 168 168 + 169 169 + /* Compute rdt_min_closid across all resources */ 170 170 + list_for_each_entry(s, &resctrl_schema_all, list) 171 171 + rdt_min_closid = min(rdt_min_closid, s->num_closid); 172 172 + 173 173 + closid_free_map = bitmap_alloc(rdt_min_closid, GFP_KERNEL); 174 174 + if (!closid_free_map) 175 175 + return -ENOMEM; 176 176 + bitmap_fill(closid_free_map, rdt_min_closid); 177 177 + 178 178 + /* RESCTRL_RESERVED_CLOSID is always reserved for the default group */ 179 179 + __clear_bit(RESCTRL_RESERVED_CLOSID, closid_free_map); 180 180 + closid_free_map_len = rdt_min_closid; 181 181 + 182 182 + return 0; 183 183 + } 184 184 + 185 185 + static void closid_exit(void) 186 186 + { 187 187 + bitmap_free(closid_free_map); 188 188 + closid_free_map = NULL; 189 189 + } 190 190 + 191 191 + static int closid_alloc(void) 192 192 + { 193 193 + int cleanest_closid; 194 194 + u32 closid; 195 195 + 196 196 + lockdep_assert_held(&rdtgroup_mutex); 197 197 + 198 198 + if (IS_ENABLED(CONFIG_RESCTRL_RMID_DEPENDS_ON_CLOSID) && 199 199 + resctrl_arch_is_llc_occupancy_enabled()) { 200 200 + cleanest_closid = resctrl_find_cleanest_closid(); 201 201 + if (cleanest_closid < 0) 202 202 + return cleanest_closid; 203 203 + closid = cleanest_closid; 204 204 + } else { 205 205 + closid = find_first_bit(closid_free_map, closid_free_map_len); 206 206 + if (closid == closid_free_map_len) 207 207 + return -ENOSPC; 208 208 + } 209 209 + __clear_bit(closid, closid_free_map); 210 210 + 211 211 + return closid; 212 212 + } 213 213 + 214 214 + void closid_free(int closid) 215 215 + { 216 216 + lockdep_assert_held(&rdtgroup_mutex); 217 217 + 218 218 + __set_bit(closid, closid_free_map); 219 219 + } 220 220 + 221 221 + /** 222 222 + * closid_allocated - test if provided closid is in use 223 223 + * @closid: closid to be tested 224 224 + * 225 225 + * Return: true if @closid is currently associated with a resource group, 226 226 + * false if @closid is free 227 227 + */ 228 228 + bool closid_allocated(unsigned int closid) 229 229 + { 230 230 + lockdep_assert_held(&rdtgroup_mutex); 231 231 + 232 232 + return !test_bit(closid, closid_free_map); 233 233 + } 234 234 + 235 235 + /** 236 236 + * rdtgroup_mode_by_closid - Return mode of resource group with closid 237 237 + * @closid: closid if the resource group 238 238 + * 239 239 + * Each resource group is associated with a @closid. Here the mode 240 240 + * of a resource group can be queried by searching for it using its closid. 241 241 + * 242 242 + * Return: mode as &enum rdtgrp_mode of resource group with closid @closid 243 243 + */ 244 244 + enum rdtgrp_mode rdtgroup_mode_by_closid(int closid) 245 245 + { 246 246 + struct rdtgroup *rdtgrp; 247 247 + 248 248 + list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 249 249 + if (rdtgrp->closid == closid) 250 250 + return rdtgrp->mode; 251 251 + } 252 252 + 253 253 + return RDT_NUM_MODES; 254 254 + } 255 255 + 256 256 + static const char * const rdt_mode_str[] = { 257 257 + [RDT_MODE_SHAREABLE] = "shareable", 258 258 + [RDT_MODE_EXCLUSIVE] = "exclusive", 259 259 + [RDT_MODE_PSEUDO_LOCKSETUP] = "pseudo-locksetup", 260 260 + [RDT_MODE_PSEUDO_LOCKED] = "pseudo-locked", 261 261 + }; 262 262 + 263 263 + /** 264 264 + * rdtgroup_mode_str - Return the string representation of mode 265 265 + * @mode: the resource group mode as &enum rdtgroup_mode 266 266 + * 267 267 + * Return: string representation of valid mode, "unknown" otherwise 268 268 + */ 269 269 + static const char *rdtgroup_mode_str(enum rdtgrp_mode mode) 270 270 + { 271 271 + if (mode < RDT_MODE_SHAREABLE || mode >= RDT_NUM_MODES) 272 272 + return "unknown"; 273 273 + 274 274 + return rdt_mode_str[mode]; 275 275 + } 276 276 + 277 277 + /* set uid and gid of rdtgroup dirs and files to that of the creator */ 278 278 + static int rdtgroup_kn_set_ugid(struct kernfs_node *kn) 279 279 + { 280 280 + struct iattr iattr = { .ia_valid = ATTR_UID | ATTR_GID, 281 281 + .ia_uid = current_fsuid(), 282 282 + .ia_gid = current_fsgid(), }; 283 283 + 284 284 + if (uid_eq(iattr.ia_uid, GLOBAL_ROOT_UID) && 285 285 + gid_eq(iattr.ia_gid, GLOBAL_ROOT_GID)) 286 286 + return 0; 287 287 + 288 288 + return kernfs_setattr(kn, &iattr); 289 289 + } 290 290 + 291 291 + static int rdtgroup_add_file(struct kernfs_node *parent_kn, struct rftype *rft) 292 292 + { 293 293 + struct kernfs_node *kn; 294 294 + int ret; 295 295 + 296 296 + kn = __kernfs_create_file(parent_kn, rft->name, rft->mode, 297 297 + GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 298 298 + 0, rft->kf_ops, rft, NULL, NULL); 299 299 + if (IS_ERR(kn)) 300 300 + return PTR_ERR(kn); 301 301 + 302 302 + ret = rdtgroup_kn_set_ugid(kn); 303 303 + if (ret) { 304 304 + kernfs_remove(kn); 305 305 + return ret; 306 306 + } 307 307 + 308 308 + return 0; 309 309 + } 310 310 + 311 311 + static int rdtgroup_seqfile_show(struct seq_file *m, void *arg) 312 312 + { 313 313 + struct kernfs_open_file *of = m->private; 314 314 + struct rftype *rft = of->kn->priv; 315 315 + 316 316 + if (rft->seq_show) 317 317 + return rft->seq_show(of, m, arg); 318 318 + return 0; 319 319 + } 320 320 + 321 321 + static ssize_t rdtgroup_file_write(struct kernfs_open_file *of, char *buf, 322 322 + size_t nbytes, loff_t off) 323 323 + { 324 324 + struct rftype *rft = of->kn->priv; 325 325 + 326 326 + if (rft->write) 327 327 + return rft->write(of, buf, nbytes, off); 328 328 + 329 329 + return -EINVAL; 330 330 + } 331 331 + 332 332 + static const struct kernfs_ops rdtgroup_kf_single_ops = { 333 333 + .atomic_write_len = PAGE_SIZE, 334 334 + .write = rdtgroup_file_write, 335 335 + .seq_show = rdtgroup_seqfile_show, 336 336 + }; 337 337 + 338 338 + static const struct kernfs_ops kf_mondata_ops = { 339 339 + .atomic_write_len = PAGE_SIZE, 340 340 + .seq_show = rdtgroup_mondata_show, 341 341 + }; 342 342 + 343 343 + static bool is_cpu_list(struct kernfs_open_file *of) 344 344 + { 345 345 + struct rftype *rft = of->kn->priv; 346 346 + 347 347 + return rft->flags & RFTYPE_FLAGS_CPUS_LIST; 348 348 + } 349 349 + 350 350 + static int rdtgroup_cpus_show(struct kernfs_open_file *of, 351 351 + struct seq_file *s, void *v) 352 352 + { 353 353 + struct rdtgroup *rdtgrp; 354 354 + struct cpumask *mask; 355 355 + int ret = 0; 356 356 + 357 357 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 358 358 + 359 359 + if (rdtgrp) { 360 360 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 361 361 + if (!rdtgrp->plr->d) { 362 362 + rdt_last_cmd_clear(); 363 363 + rdt_last_cmd_puts("Cache domain offline\n"); 364 364 + ret = -ENODEV; 365 365 + } else { 366 366 + mask = &rdtgrp->plr->d->hdr.cpu_mask; 367 367 + seq_printf(s, is_cpu_list(of) ? 368 368 + "%*pbl\n" : "%*pb\n", 369 369 + cpumask_pr_args(mask)); 370 370 + } 371 371 + } else { 372 372 + seq_printf(s, is_cpu_list(of) ? "%*pbl\n" : "%*pb\n", 373 373 + cpumask_pr_args(&rdtgrp->cpu_mask)); 374 374 + } 375 375 + } else { 376 376 + ret = -ENOENT; 377 377 + } 378 378 + rdtgroup_kn_unlock(of->kn); 379 379 + 380 380 + return ret; 381 381 + } 382 382 + 383 383 + /* 384 384 + * Update the PGR_ASSOC MSR on all cpus in @cpu_mask, 385 385 + * 386 386 + * Per task closids/rmids must have been set up before calling this function. 387 387 + * @r may be NULL. 388 388 + */ 389 389 + static void 390 390 + update_closid_rmid(const struct cpumask *cpu_mask, struct rdtgroup *r) 391 391 + { 392 392 + struct resctrl_cpu_defaults defaults, *p = NULL; 393 393 + 394 394 + if (r) { 395 395 + defaults.closid = r->closid; 396 396 + defaults.rmid = r->mon.rmid; 397 397 + p = &defaults; 398 398 + } 399 399 + 400 400 + on_each_cpu_mask(cpu_mask, resctrl_arch_sync_cpu_closid_rmid, p, 1); 401 401 + } 402 402 + 403 403 + static int cpus_mon_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 404 404 + cpumask_var_t tmpmask) 405 405 + { 406 406 + struct rdtgroup *prgrp = rdtgrp->mon.parent, *crgrp; 407 407 + struct list_head *head; 408 408 + 409 409 + /* Check whether cpus belong to parent ctrl group */ 410 410 + cpumask_andnot(tmpmask, newmask, &prgrp->cpu_mask); 411 411 + if (!cpumask_empty(tmpmask)) { 412 412 + rdt_last_cmd_puts("Can only add CPUs to mongroup that belong to parent\n"); 413 413 + return -EINVAL; 414 414 + } 415 415 + 416 416 + /* Check whether cpus are dropped from this group */ 417 417 + cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 418 418 + if (!cpumask_empty(tmpmask)) { 419 419 + /* Give any dropped cpus to parent rdtgroup */ 420 420 + cpumask_or(&prgrp->cpu_mask, &prgrp->cpu_mask, tmpmask); 421 421 + update_closid_rmid(tmpmask, prgrp); 422 422 + } 423 423 + 424 424 + /* 425 425 + * If we added cpus, remove them from previous group that owned them 426 426 + * and update per-cpu rmid 427 427 + */ 428 428 + cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 429 429 + if (!cpumask_empty(tmpmask)) { 430 430 + head = &prgrp->mon.crdtgrp_list; 431 431 + list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 432 432 + if (crgrp == rdtgrp) 433 433 + continue; 434 434 + cpumask_andnot(&crgrp->cpu_mask, &crgrp->cpu_mask, 435 435 + tmpmask); 436 436 + } 437 437 + update_closid_rmid(tmpmask, rdtgrp); 438 438 + } 439 439 + 440 440 + /* Done pushing/pulling - update this group with new mask */ 441 441 + cpumask_copy(&rdtgrp->cpu_mask, newmask); 442 442 + 443 443 + return 0; 444 444 + } 445 445 + 446 446 + static void cpumask_rdtgrp_clear(struct rdtgroup *r, struct cpumask *m) 447 447 + { 448 448 + struct rdtgroup *crgrp; 449 449 + 450 450 + cpumask_andnot(&r->cpu_mask, &r->cpu_mask, m); 451 451 + /* update the child mon group masks as well*/ 452 452 + list_for_each_entry(crgrp, &r->mon.crdtgrp_list, mon.crdtgrp_list) 453 453 + cpumask_and(&crgrp->cpu_mask, &r->cpu_mask, &crgrp->cpu_mask); 454 454 + } 455 455 + 456 456 + static int cpus_ctrl_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, 457 457 + cpumask_var_t tmpmask, cpumask_var_t tmpmask1) 458 458 + { 459 459 + struct rdtgroup *r, *crgrp; 460 460 + struct list_head *head; 461 461 + 462 462 + /* Check whether cpus are dropped from this group */ 463 463 + cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask); 464 464 + if (!cpumask_empty(tmpmask)) { 465 465 + /* Can't drop from default group */ 466 466 + if (rdtgrp == &rdtgroup_default) { 467 467 + rdt_last_cmd_puts("Can't drop CPUs from default group\n"); 468 468 + return -EINVAL; 469 469 + } 470 470 + 471 471 + /* Give any dropped cpus to rdtgroup_default */ 472 472 + cpumask_or(&rdtgroup_default.cpu_mask, 473 473 + &rdtgroup_default.cpu_mask, tmpmask); 474 474 + update_closid_rmid(tmpmask, &rdtgroup_default); 475 475 + } 476 476 + 477 477 + /* 478 478 + * If we added cpus, remove them from previous group and 479 479 + * the prev group's child groups that owned them 480 480 + * and update per-cpu closid/rmid. 481 481 + */ 482 482 + cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask); 483 483 + if (!cpumask_empty(tmpmask)) { 484 484 + list_for_each_entry(r, &rdt_all_groups, rdtgroup_list) { 485 485 + if (r == rdtgrp) 486 486 + continue; 487 487 + cpumask_and(tmpmask1, &r->cpu_mask, tmpmask); 488 488 + if (!cpumask_empty(tmpmask1)) 489 489 + cpumask_rdtgrp_clear(r, tmpmask1); 490 490 + } 491 491 + update_closid_rmid(tmpmask, rdtgrp); 492 492 + } 493 493 + 494 494 + /* Done pushing/pulling - update this group with new mask */ 495 495 + cpumask_copy(&rdtgrp->cpu_mask, newmask); 496 496 + 497 497 + /* 498 498 + * Clear child mon group masks since there is a new parent mask 499 499 + * now and update the rmid for the cpus the child lost. 500 500 + */ 501 501 + head = &rdtgrp->mon.crdtgrp_list; 502 502 + list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 503 503 + cpumask_and(tmpmask, &rdtgrp->cpu_mask, &crgrp->cpu_mask); 504 504 + update_closid_rmid(tmpmask, rdtgrp); 505 505 + cpumask_clear(&crgrp->cpu_mask); 506 506 + } 507 507 + 508 508 + return 0; 509 509 + } 510 510 + 511 511 + static ssize_t rdtgroup_cpus_write(struct kernfs_open_file *of, 512 512 + char *buf, size_t nbytes, loff_t off) 513 513 + { 514 514 + cpumask_var_t tmpmask, newmask, tmpmask1; 515 515 + struct rdtgroup *rdtgrp; 516 516 + int ret; 517 517 + 518 518 + if (!buf) 519 519 + return -EINVAL; 520 520 + 521 521 + if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 522 522 + return -ENOMEM; 523 523 + if (!zalloc_cpumask_var(&newmask, GFP_KERNEL)) { 524 524 + free_cpumask_var(tmpmask); 525 525 + return -ENOMEM; 526 526 + } 527 527 + if (!zalloc_cpumask_var(&tmpmask1, GFP_KERNEL)) { 528 528 + free_cpumask_var(tmpmask); 529 529 + free_cpumask_var(newmask); 530 530 + return -ENOMEM; 531 531 + } 532 532 + 533 533 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 534 534 + if (!rdtgrp) { 535 535 + ret = -ENOENT; 536 536 + goto unlock; 537 537 + } 538 538 + 539 539 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 540 540 + rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 541 541 + ret = -EINVAL; 542 542 + rdt_last_cmd_puts("Pseudo-locking in progress\n"); 543 543 + goto unlock; 544 544 + } 545 545 + 546 546 + if (is_cpu_list(of)) 547 547 + ret = cpulist_parse(buf, newmask); 548 548 + else 549 549 + ret = cpumask_parse(buf, newmask); 550 550 + 551 551 + if (ret) { 552 552 + rdt_last_cmd_puts("Bad CPU list/mask\n"); 553 553 + goto unlock; 554 554 + } 555 555 + 556 556 + /* check that user didn't specify any offline cpus */ 557 557 + cpumask_andnot(tmpmask, newmask, cpu_online_mask); 558 558 + if (!cpumask_empty(tmpmask)) { 559 559 + ret = -EINVAL; 560 560 + rdt_last_cmd_puts("Can only assign online CPUs\n"); 561 561 + goto unlock; 562 562 + } 563 563 + 564 564 + if (rdtgrp->type == RDTCTRL_GROUP) 565 565 + ret = cpus_ctrl_write(rdtgrp, newmask, tmpmask, tmpmask1); 566 566 + else if (rdtgrp->type == RDTMON_GROUP) 567 567 + ret = cpus_mon_write(rdtgrp, newmask, tmpmask); 568 568 + else 569 569 + ret = -EINVAL; 570 570 + 571 571 + unlock: 572 572 + rdtgroup_kn_unlock(of->kn); 573 573 + free_cpumask_var(tmpmask); 574 574 + free_cpumask_var(newmask); 575 575 + free_cpumask_var(tmpmask1); 576 576 + 577 577 + return ret ?: nbytes; 578 578 + } 579 579 + 580 580 + /** 581 581 + * rdtgroup_remove - the helper to remove resource group safely 582 582 + * @rdtgrp: resource group to remove 583 583 + * 584 584 + * On resource group creation via a mkdir, an extra kernfs_node reference is 585 585 + * taken to ensure that the rdtgroup structure remains accessible for the 586 586 + * rdtgroup_kn_unlock() calls where it is removed. 587 587 + * 588 588 + * Drop the extra reference here, then free the rdtgroup structure. 589 589 + * 590 590 + * Return: void 591 591 + */ 592 592 + static void rdtgroup_remove(struct rdtgroup *rdtgrp) 593 593 + { 594 594 + kernfs_put(rdtgrp->kn); 595 595 + kfree(rdtgrp); 596 596 + } 597 597 + 598 598 + static void _update_task_closid_rmid(void *task) 599 599 + { 600 600 + /* 601 601 + * If the task is still current on this CPU, update PQR_ASSOC MSR. 602 602 + * Otherwise, the MSR is updated when the task is scheduled in. 603 603 + */ 604 604 + if (task == current) 605 605 + resctrl_arch_sched_in(task); 606 606 + } 607 607 + 608 608 + static void update_task_closid_rmid(struct task_struct *t) 609 609 + { 610 610 + if (IS_ENABLED(CONFIG_SMP) && task_curr(t)) 611 611 + smp_call_function_single(task_cpu(t), _update_task_closid_rmid, t, 1); 612 612 + else 613 613 + _update_task_closid_rmid(t); 614 614 + } 615 615 + 616 616 + static bool task_in_rdtgroup(struct task_struct *tsk, struct rdtgroup *rdtgrp) 617 617 + { 618 618 + u32 closid, rmid = rdtgrp->mon.rmid; 619 619 + 620 620 + if (rdtgrp->type == RDTCTRL_GROUP) 621 621 + closid = rdtgrp->closid; 622 622 + else if (rdtgrp->type == RDTMON_GROUP) 623 623 + closid = rdtgrp->mon.parent->closid; 624 624 + else 625 625 + return false; 626 626 + 627 627 + return resctrl_arch_match_closid(tsk, closid) && 628 628 + resctrl_arch_match_rmid(tsk, closid, rmid); 629 629 + } 630 630 + 631 631 + static int __rdtgroup_move_task(struct task_struct *tsk, 632 632 + struct rdtgroup *rdtgrp) 633 633 + { 634 634 + /* If the task is already in rdtgrp, no need to move the task. */ 635 635 + if (task_in_rdtgroup(tsk, rdtgrp)) 636 636 + return 0; 637 637 + 638 638 + /* 639 639 + * Set the task's closid/rmid before the PQR_ASSOC MSR can be 640 640 + * updated by them. 641 641 + * 642 642 + * For ctrl_mon groups, move both closid and rmid. 643 643 + * For monitor groups, can move the tasks only from 644 644 + * their parent CTRL group. 645 645 + */ 646 646 + if (rdtgrp->type == RDTMON_GROUP && 647 647 + !resctrl_arch_match_closid(tsk, rdtgrp->mon.parent->closid)) { 648 648 + rdt_last_cmd_puts("Can't move task to different control group\n"); 649 649 + return -EINVAL; 650 650 + } 651 651 + 652 652 + if (rdtgrp->type == RDTMON_GROUP) 653 653 + resctrl_arch_set_closid_rmid(tsk, rdtgrp->mon.parent->closid, 654 654 + rdtgrp->mon.rmid); 655 655 + else 656 656 + resctrl_arch_set_closid_rmid(tsk, rdtgrp->closid, 657 657 + rdtgrp->mon.rmid); 658 658 + 659 659 + /* 660 660 + * Ensure the task's closid and rmid are written before determining if 661 661 + * the task is current that will decide if it will be interrupted. 662 662 + * This pairs with the full barrier between the rq->curr update and 663 663 + * resctrl_arch_sched_in() during context switch. 664 664 + */ 665 665 + smp_mb(); 666 666 + 667 667 + /* 668 668 + * By now, the task's closid and rmid are set. If the task is current 669 669 + * on a CPU, the PQR_ASSOC MSR needs to be updated to make the resource 670 670 + * group go into effect. If the task is not current, the MSR will be 671 671 + * updated when the task is scheduled in. 672 672 + */ 673 673 + update_task_closid_rmid(tsk); 674 674 + 675 675 + return 0; 676 676 + } 677 677 + 678 678 + static bool is_closid_match(struct task_struct *t, struct rdtgroup *r) 679 679 + { 680 680 + return (resctrl_arch_alloc_capable() && (r->type == RDTCTRL_GROUP) && 681 681 + resctrl_arch_match_closid(t, r->closid)); 682 682 + } 683 683 + 684 684 + static bool is_rmid_match(struct task_struct *t, struct rdtgroup *r) 685 685 + { 686 686 + return (resctrl_arch_mon_capable() && (r->type == RDTMON_GROUP) && 687 687 + resctrl_arch_match_rmid(t, r->mon.parent->closid, 688 688 + r->mon.rmid)); 689 689 + } 690 690 + 691 691 + /** 692 692 + * rdtgroup_tasks_assigned - Test if tasks have been assigned to resource group 693 693 + * @r: Resource group 694 694 + * 695 695 + * Return: 1 if tasks have been assigned to @r, 0 otherwise 696 696 + */ 697 697 + int rdtgroup_tasks_assigned(struct rdtgroup *r) 698 698 + { 699 699 + struct task_struct *p, *t; 700 700 + int ret = 0; 701 701 + 702 702 + lockdep_assert_held(&rdtgroup_mutex); 703 703 + 704 704 + rcu_read_lock(); 705 705 + for_each_process_thread(p, t) { 706 706 + if (is_closid_match(t, r) || is_rmid_match(t, r)) { 707 707 + ret = 1; 708 708 + break; 709 709 + } 710 710 + } 711 711 + rcu_read_unlock(); 712 712 + 713 713 + return ret; 714 714 + } 715 715 + 716 716 + static int rdtgroup_task_write_permission(struct task_struct *task, 717 717 + struct kernfs_open_file *of) 718 718 + { 719 719 + const struct cred *tcred = get_task_cred(task); 720 720 + const struct cred *cred = current_cred(); 721 721 + int ret = 0; 722 722 + 723 723 + /* 724 724 + * Even if we're attaching all tasks in the thread group, we only 725 725 + * need to check permissions on one of them. 726 726 + */ 727 727 + if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) && 728 728 + !uid_eq(cred->euid, tcred->uid) && 729 729 + !uid_eq(cred->euid, tcred->suid)) { 730 730 + rdt_last_cmd_printf("No permission to move task %d\n", task->pid); 731 731 + ret = -EPERM; 732 732 + } 733 733 + 734 734 + put_cred(tcred); 735 735 + return ret; 736 736 + } 737 737 + 738 738 + static int rdtgroup_move_task(pid_t pid, struct rdtgroup *rdtgrp, 739 739 + struct kernfs_open_file *of) 740 740 + { 741 741 + struct task_struct *tsk; 742 742 + int ret; 743 743 + 744 744 + rcu_read_lock(); 745 745 + if (pid) { 746 746 + tsk = find_task_by_vpid(pid); 747 747 + if (!tsk) { 748 748 + rcu_read_unlock(); 749 749 + rdt_last_cmd_printf("No task %d\n", pid); 750 750 + return -ESRCH; 751 751 + } 752 752 + } else { 753 753 + tsk = current; 754 754 + } 755 755 + 756 756 + get_task_struct(tsk); 757 757 + rcu_read_unlock(); 758 758 + 759 759 + ret = rdtgroup_task_write_permission(tsk, of); 760 760 + if (!ret) 761 761 + ret = __rdtgroup_move_task(tsk, rdtgrp); 762 762 + 763 763 + put_task_struct(tsk); 764 764 + return ret; 765 765 + } 766 766 + 767 767 + static ssize_t rdtgroup_tasks_write(struct kernfs_open_file *of, 768 768 + char *buf, size_t nbytes, loff_t off) 769 769 + { 770 770 + struct rdtgroup *rdtgrp; 771 771 + char *pid_str; 772 772 + int ret = 0; 773 773 + pid_t pid; 774 774 + 775 775 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 776 776 + if (!rdtgrp) { 777 777 + rdtgroup_kn_unlock(of->kn); 778 778 + return -ENOENT; 779 779 + } 780 780 + rdt_last_cmd_clear(); 781 781 + 782 782 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED || 783 783 + rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 784 784 + ret = -EINVAL; 785 785 + rdt_last_cmd_puts("Pseudo-locking in progress\n"); 786 786 + goto unlock; 787 787 + } 788 788 + 789 789 + while (buf && buf[0] != '\0' && buf[0] != '\n') { 790 790 + pid_str = strim(strsep(&buf, ",")); 791 791 + 792 792 + if (kstrtoint(pid_str, 0, &pid)) { 793 793 + rdt_last_cmd_printf("Task list parsing error pid %s\n", pid_str); 794 794 + ret = -EINVAL; 795 795 + break; 796 796 + } 797 797 + 798 798 + if (pid < 0) { 799 799 + rdt_last_cmd_printf("Invalid pid %d\n", pid); 800 800 + ret = -EINVAL; 801 801 + break; 802 802 + } 803 803 + 804 804 + ret = rdtgroup_move_task(pid, rdtgrp, of); 805 805 + if (ret) { 806 806 + rdt_last_cmd_printf("Error while processing task %d\n", pid); 807 807 + break; 808 808 + } 809 809 + } 810 810 + 811 811 + unlock: 812 812 + rdtgroup_kn_unlock(of->kn); 813 813 + 814 814 + return ret ?: nbytes; 815 815 + } 816 816 + 817 817 + static void show_rdt_tasks(struct rdtgroup *r, struct seq_file *s) 818 818 + { 819 819 + struct task_struct *p, *t; 820 820 + pid_t pid; 821 821 + 822 822 + rcu_read_lock(); 823 823 + for_each_process_thread(p, t) { 824 824 + if (is_closid_match(t, r) || is_rmid_match(t, r)) { 825 825 + pid = task_pid_vnr(t); 826 826 + if (pid) 827 827 + seq_printf(s, "%d\n", pid); 828 828 + } 829 829 + } 830 830 + rcu_read_unlock(); 831 831 + } 832 832 + 833 833 + static int rdtgroup_tasks_show(struct kernfs_open_file *of, 834 834 + struct seq_file *s, void *v) 835 835 + { 836 836 + struct rdtgroup *rdtgrp; 837 837 + int ret = 0; 838 838 + 839 839 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 840 840 + if (rdtgrp) 841 841 + show_rdt_tasks(rdtgrp, s); 842 842 + else 843 843 + ret = -ENOENT; 844 844 + rdtgroup_kn_unlock(of->kn); 845 845 + 846 846 + return ret; 847 847 + } 848 848 + 849 849 + static int rdtgroup_closid_show(struct kernfs_open_file *of, 850 850 + struct seq_file *s, void *v) 851 851 + { 852 852 + struct rdtgroup *rdtgrp; 853 853 + int ret = 0; 854 854 + 855 855 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 856 856 + if (rdtgrp) 857 857 + seq_printf(s, "%u\n", rdtgrp->closid); 858 858 + else 859 859 + ret = -ENOENT; 860 860 + rdtgroup_kn_unlock(of->kn); 861 861 + 862 862 + return ret; 863 863 + } 864 864 + 865 865 + static int rdtgroup_rmid_show(struct kernfs_open_file *of, 866 866 + struct seq_file *s, void *v) 867 867 + { 868 868 + struct rdtgroup *rdtgrp; 869 869 + int ret = 0; 870 870 + 871 871 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 872 872 + if (rdtgrp) 873 873 + seq_printf(s, "%u\n", rdtgrp->mon.rmid); 874 874 + else 875 875 + ret = -ENOENT; 876 876 + rdtgroup_kn_unlock(of->kn); 877 877 + 878 878 + return ret; 879 879 + } 880 880 + 881 881 + #ifdef CONFIG_PROC_CPU_RESCTRL 882 882 + /* 883 883 + * A task can only be part of one resctrl control group and of one monitor 884 884 + * group which is associated to that control group. 885 885 + * 886 886 + * 1) res: 887 887 + * mon: 888 888 + * 889 889 + * resctrl is not available. 890 890 + * 891 891 + * 2) res:/ 892 892 + * mon: 893 893 + * 894 894 + * Task is part of the root resctrl control group, and it is not associated 895 895 + * to any monitor group. 896 896 + * 897 897 + * 3) res:/ 898 898 + * mon:mon0 899 899 + * 900 900 + * Task is part of the root resctrl control group and monitor group mon0. 901 901 + * 902 902 + * 4) res:group0 903 903 + * mon: 904 904 + * 905 905 + * Task is part of resctrl control group group0, and it is not associated 906 906 + * to any monitor group. 907 907 + * 908 908 + * 5) res:group0 909 909 + * mon:mon1 910 910 + * 911 911 + * Task is part of resctrl control group group0 and monitor group mon1. 912 912 + */ 913 913 + int proc_resctrl_show(struct seq_file *s, struct pid_namespace *ns, 914 914 + struct pid *pid, struct task_struct *tsk) 915 915 + { 916 916 + struct rdtgroup *rdtg; 917 917 + int ret = 0; 918 918 + 919 919 + mutex_lock(&rdtgroup_mutex); 920 920 + 921 921 + /* Return empty if resctrl has not been mounted. */ 922 922 + if (!resctrl_mounted) { 923 923 + seq_puts(s, "res:\nmon:\n"); 924 924 + goto unlock; 925 925 + } 926 926 + 927 927 + list_for_each_entry(rdtg, &rdt_all_groups, rdtgroup_list) { 928 928 + struct rdtgroup *crg; 929 929 + 930 930 + /* 931 931 + * Task information is only relevant for shareable 932 932 + * and exclusive groups. 933 933 + */ 934 934 + if (rdtg->mode != RDT_MODE_SHAREABLE && 935 935 + rdtg->mode != RDT_MODE_EXCLUSIVE) 936 936 + continue; 937 937 + 938 938 + if (!resctrl_arch_match_closid(tsk, rdtg->closid)) 939 939 + continue; 940 940 + 941 941 + seq_printf(s, "res:%s%s\n", (rdtg == &rdtgroup_default) ? "/" : "", 942 942 + rdt_kn_name(rdtg->kn)); 943 943 + seq_puts(s, "mon:"); 944 944 + list_for_each_entry(crg, &rdtg->mon.crdtgrp_list, 945 945 + mon.crdtgrp_list) { 946 946 + if (!resctrl_arch_match_rmid(tsk, crg->mon.parent->closid, 947 947 + crg->mon.rmid)) 948 948 + continue; 949 949 + seq_printf(s, "%s", rdt_kn_name(crg->kn)); 950 950 + break; 951 951 + } 952 952 + seq_putc(s, '\n'); 953 953 + goto unlock; 954 954 + } 955 955 + /* 956 956 + * The above search should succeed. Otherwise return 957 957 + * with an error. 958 958 + */ 959 959 + ret = -ENOENT; 960 960 + unlock: 961 961 + mutex_unlock(&rdtgroup_mutex); 962 962 + 963 963 + return ret; 964 964 + } 965 965 + #endif 966 966 + 967 967 + static int rdt_last_cmd_status_show(struct kernfs_open_file *of, 968 968 + struct seq_file *seq, void *v) 969 969 + { 970 970 + int len; 971 971 + 972 972 + mutex_lock(&rdtgroup_mutex); 973 973 + len = seq_buf_used(&last_cmd_status); 974 974 + if (len) 975 975 + seq_printf(seq, "%.*s", len, last_cmd_status_buf); 976 976 + else 977 977 + seq_puts(seq, "ok\n"); 978 978 + mutex_unlock(&rdtgroup_mutex); 979 979 + return 0; 980 980 + } 981 981 + 982 982 + static void *rdt_kn_parent_priv(struct kernfs_node *kn) 983 983 + { 984 984 + /* 985 985 + * The parent pointer is only valid within RCU section since it can be 986 986 + * replaced. 987 987 + */ 988 988 + guard(rcu)(); 989 989 + return rcu_dereference(kn->__parent)->priv; 990 990 + } 991 991 + 992 992 + static int rdt_num_closids_show(struct kernfs_open_file *of, 993 993 + struct seq_file *seq, void *v) 994 994 + { 995 995 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 996 996 + 997 997 + seq_printf(seq, "%u\n", s->num_closid); 998 998 + return 0; 999 999 + } 1000 1000 + 1001 1001 + static int rdt_default_ctrl_show(struct kernfs_open_file *of, 1002 1002 + struct seq_file *seq, void *v) 1003 1003 + { 1004 1004 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1005 1005 + struct rdt_resource *r = s->res; 1006 1006 + 1007 1007 + seq_printf(seq, "%x\n", resctrl_get_default_ctrl(r)); 1008 1008 + return 0; 1009 1009 + } 1010 1010 + 1011 1011 + static int rdt_min_cbm_bits_show(struct kernfs_open_file *of, 1012 1012 + struct seq_file *seq, void *v) 1013 1013 + { 1014 1014 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1015 1015 + struct rdt_resource *r = s->res; 1016 1016 + 1017 1017 + seq_printf(seq, "%u\n", r->cache.min_cbm_bits); 1018 1018 + return 0; 1019 1019 + } 1020 1020 + 1021 1021 + static int rdt_shareable_bits_show(struct kernfs_open_file *of, 1022 1022 + struct seq_file *seq, void *v) 1023 1023 + { 1024 1024 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1025 1025 + struct rdt_resource *r = s->res; 1026 1026 + 1027 1027 + seq_printf(seq, "%x\n", r->cache.shareable_bits); 1028 1028 + return 0; 1029 1029 + } 1030 1030 + 1031 1031 + /* 1032 1032 + * rdt_bit_usage_show - Display current usage of resources 1033 1033 + * 1034 1034 + * A domain is a shared resource that can now be allocated differently. Here 1035 1035 + * we display the current regions of the domain as an annotated bitmask. 1036 1036 + * For each domain of this resource its allocation bitmask 1037 1037 + * is annotated as below to indicate the current usage of the corresponding bit: 1038 1038 + * 0 - currently unused 1039 1039 + * X - currently available for sharing and used by software and hardware 1040 1040 + * H - currently used by hardware only but available for software use 1041 1041 + * S - currently used and shareable by software only 1042 1042 + * E - currently used exclusively by one resource group 1043 1043 + * P - currently pseudo-locked by one resource group 1044 1044 + */ 1045 1045 + static int rdt_bit_usage_show(struct kernfs_open_file *of, 1046 1046 + struct seq_file *seq, void *v) 1047 1047 + { 1048 1048 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1049 1049 + /* 1050 1050 + * Use unsigned long even though only 32 bits are used to ensure 1051 1051 + * test_bit() is used safely. 1052 1052 + */ 1053 1053 + unsigned long sw_shareable = 0, hw_shareable = 0; 1054 1054 + unsigned long exclusive = 0, pseudo_locked = 0; 1055 1055 + struct rdt_resource *r = s->res; 1056 1056 + struct rdt_ctrl_domain *dom; 1057 1057 + int i, hwb, swb, excl, psl; 1058 1058 + enum rdtgrp_mode mode; 1059 1059 + bool sep = false; 1060 1060 + u32 ctrl_val; 1061 1061 + 1062 1062 + cpus_read_lock(); 1063 1063 + mutex_lock(&rdtgroup_mutex); 1064 1064 + hw_shareable = r->cache.shareable_bits; 1065 1065 + list_for_each_entry(dom, &r->ctrl_domains, hdr.list) { 1066 1066 + if (sep) 1067 1067 + seq_putc(seq, ';'); 1068 1068 + sw_shareable = 0; 1069 1069 + exclusive = 0; 1070 1070 + seq_printf(seq, "%d=", dom->hdr.id); 1071 1071 + for (i = 0; i < closids_supported(); i++) { 1072 1072 + if (!closid_allocated(i)) 1073 1073 + continue; 1074 1074 + ctrl_val = resctrl_arch_get_config(r, dom, i, 1075 1075 + s->conf_type); 1076 1076 + mode = rdtgroup_mode_by_closid(i); 1077 1077 + switch (mode) { 1078 1078 + case RDT_MODE_SHAREABLE: 1079 1079 + sw_shareable |= ctrl_val; 1080 1080 + break; 1081 1081 + case RDT_MODE_EXCLUSIVE: 1082 1082 + exclusive |= ctrl_val; 1083 1083 + break; 1084 1084 + case RDT_MODE_PSEUDO_LOCKSETUP: 1085 1085 + /* 1086 1086 + * RDT_MODE_PSEUDO_LOCKSETUP is possible 1087 1087 + * here but not included since the CBM 1088 1088 + * associated with this CLOSID in this mode 1089 1089 + * is not initialized and no task or cpu can be 1090 1090 + * assigned this CLOSID. 1091 1091 + */ 1092 1092 + break; 1093 1093 + case RDT_MODE_PSEUDO_LOCKED: 1094 1094 + case RDT_NUM_MODES: 1095 1095 + WARN(1, 1096 1096 + "invalid mode for closid %d\n", i); 1097 1097 + break; 1098 1098 + } 1099 1099 + } 1100 1100 + for (i = r->cache.cbm_len - 1; i >= 0; i--) { 1101 1101 + pseudo_locked = dom->plr ? dom->plr->cbm : 0; 1102 1102 + hwb = test_bit(i, &hw_shareable); 1103 1103 + swb = test_bit(i, &sw_shareable); 1104 1104 + excl = test_bit(i, &exclusive); 1105 1105 + psl = test_bit(i, &pseudo_locked); 1106 1106 + if (hwb && swb) 1107 1107 + seq_putc(seq, 'X'); 1108 1108 + else if (hwb && !swb) 1109 1109 + seq_putc(seq, 'H'); 1110 1110 + else if (!hwb && swb) 1111 1111 + seq_putc(seq, 'S'); 1112 1112 + else if (excl) 1113 1113 + seq_putc(seq, 'E'); 1114 1114 + else if (psl) 1115 1115 + seq_putc(seq, 'P'); 1116 1116 + else /* Unused bits remain */ 1117 1117 + seq_putc(seq, '0'); 1118 1118 + } 1119 1119 + sep = true; 1120 1120 + } 1121 1121 + seq_putc(seq, '\n'); 1122 1122 + mutex_unlock(&rdtgroup_mutex); 1123 1123 + cpus_read_unlock(); 1124 1124 + return 0; 1125 1125 + } 1126 1126 + 1127 1127 + static int rdt_min_bw_show(struct kernfs_open_file *of, 1128 1128 + struct seq_file *seq, void *v) 1129 1129 + { 1130 1130 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1131 1131 + struct rdt_resource *r = s->res; 1132 1132 + 1133 1133 + seq_printf(seq, "%u\n", r->membw.min_bw); 1134 1134 + return 0; 1135 1135 + } 1136 1136 + 1137 1137 + static int rdt_num_rmids_show(struct kernfs_open_file *of, 1138 1138 + struct seq_file *seq, void *v) 1139 1139 + { 1140 1140 + struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 1141 1141 + 1142 1142 + seq_printf(seq, "%d\n", r->num_rmid); 1143 1143 + 1144 1144 + return 0; 1145 1145 + } 1146 1146 + 1147 1147 + static int rdt_mon_features_show(struct kernfs_open_file *of, 1148 1148 + struct seq_file *seq, void *v) 1149 1149 + { 1150 1150 + struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 1151 1151 + struct mon_evt *mevt; 1152 1152 + 1153 1153 + list_for_each_entry(mevt, &r->evt_list, list) { 1154 1154 + seq_printf(seq, "%s\n", mevt->name); 1155 1155 + if (mevt->configurable) 1156 1156 + seq_printf(seq, "%s_config\n", mevt->name); 1157 1157 + } 1158 1158 + 1159 1159 + return 0; 1160 1160 + } 1161 1161 + 1162 1162 + static int rdt_bw_gran_show(struct kernfs_open_file *of, 1163 1163 + struct seq_file *seq, void *v) 1164 1164 + { 1165 1165 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1166 1166 + struct rdt_resource *r = s->res; 1167 1167 + 1168 1168 + seq_printf(seq, "%u\n", r->membw.bw_gran); 1169 1169 + return 0; 1170 1170 + } 1171 1171 + 1172 1172 + static int rdt_delay_linear_show(struct kernfs_open_file *of, 1173 1173 + struct seq_file *seq, void *v) 1174 1174 + { 1175 1175 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1176 1176 + struct rdt_resource *r = s->res; 1177 1177 + 1178 1178 + seq_printf(seq, "%u\n", r->membw.delay_linear); 1179 1179 + return 0; 1180 1180 + } 1181 1181 + 1182 1182 + static int max_threshold_occ_show(struct kernfs_open_file *of, 1183 1183 + struct seq_file *seq, void *v) 1184 1184 + { 1185 1185 + seq_printf(seq, "%u\n", resctrl_rmid_realloc_threshold); 1186 1186 + 1187 1187 + return 0; 1188 1188 + } 1189 1189 + 1190 1190 + static int rdt_thread_throttle_mode_show(struct kernfs_open_file *of, 1191 1191 + struct seq_file *seq, void *v) 1192 1192 + { 1193 1193 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1194 1194 + struct rdt_resource *r = s->res; 1195 1195 + 1196 1196 + switch (r->membw.throttle_mode) { 1197 1197 + case THREAD_THROTTLE_PER_THREAD: 1198 1198 + seq_puts(seq, "per-thread\n"); 1199 1199 + return 0; 1200 1200 + case THREAD_THROTTLE_MAX: 1201 1201 + seq_puts(seq, "max\n"); 1202 1202 + return 0; 1203 1203 + case THREAD_THROTTLE_UNDEFINED: 1204 1204 + seq_puts(seq, "undefined\n"); 1205 1205 + return 0; 1206 1206 + } 1207 1207 + 1208 1208 + WARN_ON_ONCE(1); 1209 1209 + 1210 1210 + return 0; 1211 1211 + } 1212 1212 + 1213 1213 + static ssize_t max_threshold_occ_write(struct kernfs_open_file *of, 1214 1214 + char *buf, size_t nbytes, loff_t off) 1215 1215 + { 1216 1216 + unsigned int bytes; 1217 1217 + int ret; 1218 1218 + 1219 1219 + ret = kstrtouint(buf, 0, &bytes); 1220 1220 + if (ret) 1221 1221 + return ret; 1222 1222 + 1223 1223 + if (bytes > resctrl_rmid_realloc_limit) 1224 1224 + return -EINVAL; 1225 1225 + 1226 1226 + resctrl_rmid_realloc_threshold = resctrl_arch_round_mon_val(bytes); 1227 1227 + 1228 1228 + return nbytes; 1229 1229 + } 1230 1230 + 1231 1231 + /* 1232 1232 + * rdtgroup_mode_show - Display mode of this resource group 1233 1233 + */ 1234 1234 + static int rdtgroup_mode_show(struct kernfs_open_file *of, 1235 1235 + struct seq_file *s, void *v) 1236 1236 + { 1237 1237 + struct rdtgroup *rdtgrp; 1238 1238 + 1239 1239 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 1240 1240 + if (!rdtgrp) { 1241 1241 + rdtgroup_kn_unlock(of->kn); 1242 1242 + return -ENOENT; 1243 1243 + } 1244 1244 + 1245 1245 + seq_printf(s, "%s\n", rdtgroup_mode_str(rdtgrp->mode)); 1246 1246 + 1247 1247 + rdtgroup_kn_unlock(of->kn); 1248 1248 + return 0; 1249 1249 + } 1250 1250 + 1251 1251 + static enum resctrl_conf_type resctrl_peer_type(enum resctrl_conf_type my_type) 1252 1252 + { 1253 1253 + switch (my_type) { 1254 1254 + case CDP_CODE: 1255 1255 + return CDP_DATA; 1256 1256 + case CDP_DATA: 1257 1257 + return CDP_CODE; 1258 1258 + default: 1259 1259 + case CDP_NONE: 1260 1260 + return CDP_NONE; 1261 1261 + } 1262 1262 + } 1263 1263 + 1264 1264 + static int rdt_has_sparse_bitmasks_show(struct kernfs_open_file *of, 1265 1265 + struct seq_file *seq, void *v) 1266 1266 + { 1267 1267 + struct resctrl_schema *s = rdt_kn_parent_priv(of->kn); 1268 1268 + struct rdt_resource *r = s->res; 1269 1269 + 1270 1270 + seq_printf(seq, "%u\n", r->cache.arch_has_sparse_bitmasks); 1271 1271 + 1272 1272 + return 0; 1273 1273 + } 1274 1274 + 1275 1275 + /** 1276 1276 + * __rdtgroup_cbm_overlaps - Does CBM for intended closid overlap with other 1277 1277 + * @r: Resource to which domain instance @d belongs. 1278 1278 + * @d: The domain instance for which @closid is being tested. 1279 1279 + * @cbm: Capacity bitmask being tested. 1280 1280 + * @closid: Intended closid for @cbm. 1281 1281 + * @type: CDP type of @r. 1282 1282 + * @exclusive: Only check if overlaps with exclusive resource groups 1283 1283 + * 1284 1284 + * Checks if provided @cbm intended to be used for @closid on domain 1285 1285 + * @d overlaps with any other closids or other hardware usage associated 1286 1286 + * with this domain. If @exclusive is true then only overlaps with 1287 1287 + * resource groups in exclusive mode will be considered. If @exclusive 1288 1288 + * is false then overlaps with any resource group or hardware entities 1289 1289 + * will be considered. 1290 1290 + * 1291 1291 + * @cbm is unsigned long, even if only 32 bits are used, to make the 1292 1292 + * bitmap functions work correctly. 1293 1293 + * 1294 1294 + * Return: false if CBM does not overlap, true if it does. 1295 1295 + */ 1296 1296 + static bool __rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_ctrl_domain *d, 1297 1297 + unsigned long cbm, int closid, 1298 1298 + enum resctrl_conf_type type, bool exclusive) 1299 1299 + { 1300 1300 + enum rdtgrp_mode mode; 1301 1301 + unsigned long ctrl_b; 1302 1302 + int i; 1303 1303 + 1304 1304 + /* Check for any overlap with regions used by hardware directly */ 1305 1305 + if (!exclusive) { 1306 1306 + ctrl_b = r->cache.shareable_bits; 1307 1307 + if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) 1308 1308 + return true; 1309 1309 + } 1310 1310 + 1311 1311 + /* Check for overlap with other resource groups */ 1312 1312 + for (i = 0; i < closids_supported(); i++) { 1313 1313 + ctrl_b = resctrl_arch_get_config(r, d, i, type); 1314 1314 + mode = rdtgroup_mode_by_closid(i); 1315 1315 + if (closid_allocated(i) && i != closid && 1316 1316 + mode != RDT_MODE_PSEUDO_LOCKSETUP) { 1317 1317 + if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) { 1318 1318 + if (exclusive) { 1319 1319 + if (mode == RDT_MODE_EXCLUSIVE) 1320 1320 + return true; 1321 1321 + continue; 1322 1322 + } 1323 1323 + return true; 1324 1324 + } 1325 1325 + } 1326 1326 + } 1327 1327 + 1328 1328 + return false; 1329 1329 + } 1330 1330 + 1331 1331 + /** 1332 1332 + * rdtgroup_cbm_overlaps - Does CBM overlap with other use of hardware 1333 1333 + * @s: Schema for the resource to which domain instance @d belongs. 1334 1334 + * @d: The domain instance for which @closid is being tested. 1335 1335 + * @cbm: Capacity bitmask being tested. 1336 1336 + * @closid: Intended closid for @cbm. 1337 1337 + * @exclusive: Only check if overlaps with exclusive resource groups 1338 1338 + * 1339 1339 + * Resources that can be allocated using a CBM can use the CBM to control 1340 1340 + * the overlap of these allocations. rdtgroup_cmb_overlaps() is the test 1341 1341 + * for overlap. Overlap test is not limited to the specific resource for 1342 1342 + * which the CBM is intended though - when dealing with CDP resources that 1343 1343 + * share the underlying hardware the overlap check should be performed on 1344 1344 + * the CDP resource sharing the hardware also. 1345 1345 + * 1346 1346 + * Refer to description of __rdtgroup_cbm_overlaps() for the details of the 1347 1347 + * overlap test. 1348 1348 + * 1349 1349 + * Return: true if CBM overlap detected, false if there is no overlap 1350 1350 + */ 1351 1351 + bool rdtgroup_cbm_overlaps(struct resctrl_schema *s, struct rdt_ctrl_domain *d, 1352 1352 + unsigned long cbm, int closid, bool exclusive) 1353 1353 + { 1354 1354 + enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 1355 1355 + struct rdt_resource *r = s->res; 1356 1356 + 1357 1357 + if (__rdtgroup_cbm_overlaps(r, d, cbm, closid, s->conf_type, 1358 1358 + exclusive)) 1359 1359 + return true; 1360 1360 + 1361 1361 + if (!resctrl_arch_get_cdp_enabled(r->rid)) 1362 1362 + return false; 1363 1363 + return __rdtgroup_cbm_overlaps(r, d, cbm, closid, peer_type, exclusive); 1364 1364 + } 1365 1365 + 1366 1366 + /** 1367 1367 + * rdtgroup_mode_test_exclusive - Test if this resource group can be exclusive 1368 1368 + * @rdtgrp: Resource group identified through its closid. 1369 1369 + * 1370 1370 + * An exclusive resource group implies that there should be no sharing of 1371 1371 + * its allocated resources. At the time this group is considered to be 1372 1372 + * exclusive this test can determine if its current schemata supports this 1373 1373 + * setting by testing for overlap with all other resource groups. 1374 1374 + * 1375 1375 + * Return: true if resource group can be exclusive, false if there is overlap 1376 1376 + * with allocations of other resource groups and thus this resource group 1377 1377 + * cannot be exclusive. 1378 1378 + */ 1379 1379 + static bool rdtgroup_mode_test_exclusive(struct rdtgroup *rdtgrp) 1380 1380 + { 1381 1381 + int closid = rdtgrp->closid; 1382 1382 + struct rdt_ctrl_domain *d; 1383 1383 + struct resctrl_schema *s; 1384 1384 + struct rdt_resource *r; 1385 1385 + bool has_cache = false; 1386 1386 + u32 ctrl; 1387 1387 + 1388 1388 + /* Walking r->domains, ensure it can't race with cpuhp */ 1389 1389 + lockdep_assert_cpus_held(); 1390 1390 + 1391 1391 + list_for_each_entry(s, &resctrl_schema_all, list) { 1392 1392 + r = s->res; 1393 1393 + if (r->rid == RDT_RESOURCE_MBA || r->rid == RDT_RESOURCE_SMBA) 1394 1394 + continue; 1395 1395 + has_cache = true; 1396 1396 + list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 1397 1397 + ctrl = resctrl_arch_get_config(r, d, closid, 1398 1398 + s->conf_type); 1399 1399 + if (rdtgroup_cbm_overlaps(s, d, ctrl, closid, false)) { 1400 1400 + rdt_last_cmd_puts("Schemata overlaps\n"); 1401 1401 + return false; 1402 1402 + } 1403 1403 + } 1404 1404 + } 1405 1405 + 1406 1406 + if (!has_cache) { 1407 1407 + rdt_last_cmd_puts("Cannot be exclusive without CAT/CDP\n"); 1408 1408 + return false; 1409 1409 + } 1410 1410 + 1411 1411 + return true; 1412 1412 + } 1413 1413 + 1414 1414 + /* 1415 1415 + * rdtgroup_mode_write - Modify the resource group's mode 1416 1416 + */ 1417 1417 + static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, 1418 1418 + char *buf, size_t nbytes, loff_t off) 1419 1419 + { 1420 1420 + struct rdtgroup *rdtgrp; 1421 1421 + enum rdtgrp_mode mode; 1422 1422 + int ret = 0; 1423 1423 + 1424 1424 + /* Valid input requires a trailing newline */ 1425 1425 + if (nbytes == 0 || buf[nbytes - 1] != '\n') 1426 1426 + return -EINVAL; 1427 1427 + buf[nbytes - 1] = '\0'; 1428 1428 + 1429 1429 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 1430 1430 + if (!rdtgrp) { 1431 1431 + rdtgroup_kn_unlock(of->kn); 1432 1432 + return -ENOENT; 1433 1433 + } 1434 1434 + 1435 1435 + rdt_last_cmd_clear(); 1436 1436 + 1437 1437 + mode = rdtgrp->mode; 1438 1438 + 1439 1439 + if ((!strcmp(buf, "shareable") && mode == RDT_MODE_SHAREABLE) || 1440 1440 + (!strcmp(buf, "exclusive") && mode == RDT_MODE_EXCLUSIVE) || 1441 1441 + (!strcmp(buf, "pseudo-locksetup") && 1442 1442 + mode == RDT_MODE_PSEUDO_LOCKSETUP) || 1443 1443 + (!strcmp(buf, "pseudo-locked") && mode == RDT_MODE_PSEUDO_LOCKED)) 1444 1444 + goto out; 1445 1445 + 1446 1446 + if (mode == RDT_MODE_PSEUDO_LOCKED) { 1447 1447 + rdt_last_cmd_puts("Cannot change pseudo-locked group\n"); 1448 1448 + ret = -EINVAL; 1449 1449 + goto out; 1450 1450 + } 1451 1451 + 1452 1452 + if (!strcmp(buf, "shareable")) { 1453 1453 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1454 1454 + ret = rdtgroup_locksetup_exit(rdtgrp); 1455 1455 + if (ret) 1456 1456 + goto out; 1457 1457 + } 1458 1458 + rdtgrp->mode = RDT_MODE_SHAREABLE; 1459 1459 + } else if (!strcmp(buf, "exclusive")) { 1460 1460 + if (!rdtgroup_mode_test_exclusive(rdtgrp)) { 1461 1461 + ret = -EINVAL; 1462 1462 + goto out; 1463 1463 + } 1464 1464 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1465 1465 + ret = rdtgroup_locksetup_exit(rdtgrp); 1466 1466 + if (ret) 1467 1467 + goto out; 1468 1468 + } 1469 1469 + rdtgrp->mode = RDT_MODE_EXCLUSIVE; 1470 1470 + } else if (IS_ENABLED(CONFIG_RESCTRL_FS_PSEUDO_LOCK) && 1471 1471 + !strcmp(buf, "pseudo-locksetup")) { 1472 1472 + ret = rdtgroup_locksetup_enter(rdtgrp); 1473 1473 + if (ret) 1474 1474 + goto out; 1475 1475 + rdtgrp->mode = RDT_MODE_PSEUDO_LOCKSETUP; 1476 1476 + } else { 1477 1477 + rdt_last_cmd_puts("Unknown or unsupported mode\n"); 1478 1478 + ret = -EINVAL; 1479 1479 + } 1480 1480 + 1481 1481 + out: 1482 1482 + rdtgroup_kn_unlock(of->kn); 1483 1483 + return ret ?: nbytes; 1484 1484 + } 1485 1485 + 1486 1486 + /** 1487 1487 + * rdtgroup_cbm_to_size - Translate CBM to size in bytes 1488 1488 + * @r: RDT resource to which @d belongs. 1489 1489 + * @d: RDT domain instance. 1490 1490 + * @cbm: bitmask for which the size should be computed. 1491 1491 + * 1492 1492 + * The bitmask provided associated with the RDT domain instance @d will be 1493 1493 + * translated into how many bytes it represents. The size in bytes is 1494 1494 + * computed by first dividing the total cache size by the CBM length to 1495 1495 + * determine how many bytes each bit in the bitmask represents. The result 1496 1496 + * is multiplied with the number of bits set in the bitmask. 1497 1497 + * 1498 1498 + * @cbm is unsigned long, even if only 32 bits are used to make the 1499 1499 + * bitmap functions work correctly. 1500 1500 + */ 1501 1501 + unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, 1502 1502 + struct rdt_ctrl_domain *d, unsigned long cbm) 1503 1503 + { 1504 1504 + unsigned int size = 0; 1505 1505 + struct cacheinfo *ci; 1506 1506 + int num_b; 1507 1507 + 1508 1508 + if (WARN_ON_ONCE(r->ctrl_scope != RESCTRL_L2_CACHE && r->ctrl_scope != RESCTRL_L3_CACHE)) 1509 1509 + return size; 1510 1510 + 1511 1511 + num_b = bitmap_weight(&cbm, r->cache.cbm_len); 1512 1512 + ci = get_cpu_cacheinfo_level(cpumask_any(&d->hdr.cpu_mask), r->ctrl_scope); 1513 1513 + if (ci) 1514 1514 + size = ci->size / r->cache.cbm_len * num_b; 1515 1515 + 1516 1516 + return size; 1517 1517 + } 1518 1518 + 1519 1519 + bool is_mba_sc(struct rdt_resource *r) 1520 1520 + { 1521 1521 + if (!r) 1522 1522 + r = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 1523 1523 + 1524 1524 + /* 1525 1525 + * The software controller support is only applicable to MBA resource. 1526 1526 + * Make sure to check for resource type. 1527 1527 + */ 1528 1528 + if (r->rid != RDT_RESOURCE_MBA) 1529 1529 + return false; 1530 1530 + 1531 1531 + return r->membw.mba_sc; 1532 1532 + } 1533 1533 + 1534 1534 + /* 1535 1535 + * rdtgroup_size_show - Display size in bytes of allocated regions 1536 1536 + * 1537 1537 + * The "size" file mirrors the layout of the "schemata" file, printing the 1538 1538 + * size in bytes of each region instead of the capacity bitmask. 1539 1539 + */ 1540 1540 + static int rdtgroup_size_show(struct kernfs_open_file *of, 1541 1541 + struct seq_file *s, void *v) 1542 1542 + { 1543 1543 + struct resctrl_schema *schema; 1544 1544 + enum resctrl_conf_type type; 1545 1545 + struct rdt_ctrl_domain *d; 1546 1546 + struct rdtgroup *rdtgrp; 1547 1547 + struct rdt_resource *r; 1548 1548 + unsigned int size; 1549 1549 + int ret = 0; 1550 1550 + u32 closid; 1551 1551 + bool sep; 1552 1552 + u32 ctrl; 1553 1553 + 1554 1554 + rdtgrp = rdtgroup_kn_lock_live(of->kn); 1555 1555 + if (!rdtgrp) { 1556 1556 + rdtgroup_kn_unlock(of->kn); 1557 1557 + return -ENOENT; 1558 1558 + } 1559 1559 + 1560 1560 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 1561 1561 + if (!rdtgrp->plr->d) { 1562 1562 + rdt_last_cmd_clear(); 1563 1563 + rdt_last_cmd_puts("Cache domain offline\n"); 1564 1564 + ret = -ENODEV; 1565 1565 + } else { 1566 1566 + seq_printf(s, "%*s:", max_name_width, 1567 1567 + rdtgrp->plr->s->name); 1568 1568 + size = rdtgroup_cbm_to_size(rdtgrp->plr->s->res, 1569 1569 + rdtgrp->plr->d, 1570 1570 + rdtgrp->plr->cbm); 1571 1571 + seq_printf(s, "%d=%u\n", rdtgrp->plr->d->hdr.id, size); 1572 1572 + } 1573 1573 + goto out; 1574 1574 + } 1575 1575 + 1576 1576 + closid = rdtgrp->closid; 1577 1577 + 1578 1578 + list_for_each_entry(schema, &resctrl_schema_all, list) { 1579 1579 + r = schema->res; 1580 1580 + type = schema->conf_type; 1581 1581 + sep = false; 1582 1582 + seq_printf(s, "%*s:", max_name_width, schema->name); 1583 1583 + list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 1584 1584 + if (sep) 1585 1585 + seq_putc(s, ';'); 1586 1586 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) { 1587 1587 + size = 0; 1588 1588 + } else { 1589 1589 + if (is_mba_sc(r)) 1590 1590 + ctrl = d->mbps_val[closid]; 1591 1591 + else 1592 1592 + ctrl = resctrl_arch_get_config(r, d, 1593 1593 + closid, 1594 1594 + type); 1595 1595 + if (r->rid == RDT_RESOURCE_MBA || 1596 1596 + r->rid == RDT_RESOURCE_SMBA) 1597 1597 + size = ctrl; 1598 1598 + else 1599 1599 + size = rdtgroup_cbm_to_size(r, d, ctrl); 1600 1600 + } 1601 1601 + seq_printf(s, "%d=%u", d->hdr.id, size); 1602 1602 + sep = true; 1603 1603 + } 1604 1604 + seq_putc(s, '\n'); 1605 1605 + } 1606 1606 + 1607 1607 + out: 1608 1608 + rdtgroup_kn_unlock(of->kn); 1609 1609 + 1610 1610 + return ret; 1611 1611 + } 1612 1612 + 1613 1613 + static void mondata_config_read(struct resctrl_mon_config_info *mon_info) 1614 1614 + { 1615 1615 + smp_call_function_any(&mon_info->d->hdr.cpu_mask, 1616 1616 + resctrl_arch_mon_event_config_read, mon_info, 1); 1617 1617 + } 1618 1618 + 1619 1619 + static int mbm_config_show(struct seq_file *s, struct rdt_resource *r, u32 evtid) 1620 1620 + { 1621 1621 + struct resctrl_mon_config_info mon_info; 1622 1622 + struct rdt_mon_domain *dom; 1623 1623 + bool sep = false; 1624 1624 + 1625 1625 + cpus_read_lock(); 1626 1626 + mutex_lock(&rdtgroup_mutex); 1627 1627 + 1628 1628 + list_for_each_entry(dom, &r->mon_domains, hdr.list) { 1629 1629 + if (sep) 1630 1630 + seq_puts(s, ";"); 1631 1631 + 1632 1632 + memset(&mon_info, 0, sizeof(struct resctrl_mon_config_info)); 1633 1633 + mon_info.r = r; 1634 1634 + mon_info.d = dom; 1635 1635 + mon_info.evtid = evtid; 1636 1636 + mondata_config_read(&mon_info); 1637 1637 + 1638 1638 + seq_printf(s, "%d=0x%02x", dom->hdr.id, mon_info.mon_config); 1639 1639 + sep = true; 1640 1640 + } 1641 1641 + seq_puts(s, "\n"); 1642 1642 + 1643 1643 + mutex_unlock(&rdtgroup_mutex); 1644 1644 + cpus_read_unlock(); 1645 1645 + 1646 1646 + return 0; 1647 1647 + } 1648 1648 + 1649 1649 + static int mbm_total_bytes_config_show(struct kernfs_open_file *of, 1650 1650 + struct seq_file *seq, void *v) 1651 1651 + { 1652 1652 + struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 1653 1653 + 1654 1654 + mbm_config_show(seq, r, QOS_L3_MBM_TOTAL_EVENT_ID); 1655 1655 + 1656 1656 + return 0; 1657 1657 + } 1658 1658 + 1659 1659 + static int mbm_local_bytes_config_show(struct kernfs_open_file *of, 1660 1660 + struct seq_file *seq, void *v) 1661 1661 + { 1662 1662 + struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 1663 1663 + 1664 1664 + mbm_config_show(seq, r, QOS_L3_MBM_LOCAL_EVENT_ID); 1665 1665 + 1666 1666 + return 0; 1667 1667 + } 1668 1668 + 1669 1669 + static void mbm_config_write_domain(struct rdt_resource *r, 1670 1670 + struct rdt_mon_domain *d, u32 evtid, u32 val) 1671 1671 + { 1672 1672 + struct resctrl_mon_config_info mon_info = {0}; 1673 1673 + 1674 1674 + /* 1675 1675 + * Read the current config value first. If both are the same then 1676 1676 + * no need to write it again. 1677 1677 + */ 1678 1678 + mon_info.r = r; 1679 1679 + mon_info.d = d; 1680 1680 + mon_info.evtid = evtid; 1681 1681 + mondata_config_read(&mon_info); 1682 1682 + if (mon_info.mon_config == val) 1683 1683 + return; 1684 1684 + 1685 1685 + mon_info.mon_config = val; 1686 1686 + 1687 1687 + /* 1688 1688 + * Update MSR_IA32_EVT_CFG_BASE MSR on one of the CPUs in the 1689 1689 + * domain. The MSRs offset from MSR MSR_IA32_EVT_CFG_BASE 1690 1690 + * are scoped at the domain level. Writing any of these MSRs 1691 1691 + * on one CPU is observed by all the CPUs in the domain. 1692 1692 + */ 1693 1693 + smp_call_function_any(&d->hdr.cpu_mask, resctrl_arch_mon_event_config_write, 1694 1694 + &mon_info, 1); 1695 1695 + 1696 1696 + /* 1697 1697 + * When an Event Configuration is changed, the bandwidth counters 1698 1698 + * for all RMIDs and Events will be cleared by the hardware. The 1699 1699 + * hardware also sets MSR_IA32_QM_CTR.Unavailable (bit 62) for 1700 1700 + * every RMID on the next read to any event for every RMID. 1701 1701 + * Subsequent reads will have MSR_IA32_QM_CTR.Unavailable (bit 62) 1702 1702 + * cleared while it is tracked by the hardware. Clear the 1703 1703 + * mbm_local and mbm_total counts for all the RMIDs. 1704 1704 + */ 1705 1705 + resctrl_arch_reset_rmid_all(r, d); 1706 1706 + } 1707 1707 + 1708 1708 + static int mon_config_write(struct rdt_resource *r, char *tok, u32 evtid) 1709 1709 + { 1710 1710 + char *dom_str = NULL, *id_str; 1711 1711 + unsigned long dom_id, val; 1712 1712 + struct rdt_mon_domain *d; 1713 1713 + 1714 1714 + /* Walking r->domains, ensure it can't race with cpuhp */ 1715 1715 + lockdep_assert_cpus_held(); 1716 1716 + 1717 1717 + next: 1718 1718 + if (!tok || tok[0] == '\0') 1719 1719 + return 0; 1720 1720 + 1721 1721 + /* Start processing the strings for each domain */ 1722 1722 + dom_str = strim(strsep(&tok, ";")); 1723 1723 + id_str = strsep(&dom_str, "="); 1724 1724 + 1725 1725 + if (!id_str || kstrtoul(id_str, 10, &dom_id)) { 1726 1726 + rdt_last_cmd_puts("Missing '=' or non-numeric domain id\n"); 1727 1727 + return -EINVAL; 1728 1728 + } 1729 1729 + 1730 1730 + if (!dom_str || kstrtoul(dom_str, 16, &val)) { 1731 1731 + rdt_last_cmd_puts("Non-numeric event configuration value\n"); 1732 1732 + return -EINVAL; 1733 1733 + } 1734 1734 + 1735 1735 + /* Value from user cannot be more than the supported set of events */ 1736 1736 + if ((val & r->mbm_cfg_mask) != val) { 1737 1737 + rdt_last_cmd_printf("Invalid event configuration: max valid mask is 0x%02x\n", 1738 1738 + r->mbm_cfg_mask); 1739 1739 + return -EINVAL; 1740 1740 + } 1741 1741 + 1742 1742 + list_for_each_entry(d, &r->mon_domains, hdr.list) { 1743 1743 + if (d->hdr.id == dom_id) { 1744 1744 + mbm_config_write_domain(r, d, evtid, val); 1745 1745 + goto next; 1746 1746 + } 1747 1747 + } 1748 1748 + 1749 1749 + return -EINVAL; 1750 1750 + } 1751 1751 + 1752 1752 + static ssize_t mbm_total_bytes_config_write(struct kernfs_open_file *of, 1753 1753 + char *buf, size_t nbytes, 1754 1754 + loff_t off) 1755 1755 + { 1756 1756 + struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 1757 1757 + int ret; 1758 1758 + 1759 1759 + /* Valid input requires a trailing newline */ 1760 1760 + if (nbytes == 0 || buf[nbytes - 1] != '\n') 1761 1761 + return -EINVAL; 1762 1762 + 1763 1763 + cpus_read_lock(); 1764 1764 + mutex_lock(&rdtgroup_mutex); 1765 1765 + 1766 1766 + rdt_last_cmd_clear(); 1767 1767 + 1768 1768 + buf[nbytes - 1] = '\0'; 1769 1769 + 1770 1770 + ret = mon_config_write(r, buf, QOS_L3_MBM_TOTAL_EVENT_ID); 1771 1771 + 1772 1772 + mutex_unlock(&rdtgroup_mutex); 1773 1773 + cpus_read_unlock(); 1774 1774 + 1775 1775 + return ret ?: nbytes; 1776 1776 + } 1777 1777 + 1778 1778 + static ssize_t mbm_local_bytes_config_write(struct kernfs_open_file *of, 1779 1779 + char *buf, size_t nbytes, 1780 1780 + loff_t off) 1781 1781 + { 1782 1782 + struct rdt_resource *r = rdt_kn_parent_priv(of->kn); 1783 1783 + int ret; 1784 1784 + 1785 1785 + /* Valid input requires a trailing newline */ 1786 1786 + if (nbytes == 0 || buf[nbytes - 1] != '\n') 1787 1787 + return -EINVAL; 1788 1788 + 1789 1789 + cpus_read_lock(); 1790 1790 + mutex_lock(&rdtgroup_mutex); 1791 1791 + 1792 1792 + rdt_last_cmd_clear(); 1793 1793 + 1794 1794 + buf[nbytes - 1] = '\0'; 1795 1795 + 1796 1796 + ret = mon_config_write(r, buf, QOS_L3_MBM_LOCAL_EVENT_ID); 1797 1797 + 1798 1798 + mutex_unlock(&rdtgroup_mutex); 1799 1799 + cpus_read_unlock(); 1800 1800 + 1801 1801 + return ret ?: nbytes; 1802 1802 + } 1803 1803 + 1804 1804 + /* rdtgroup information files for one cache resource. */ 1805 1805 + static struct rftype res_common_files[] = { 1806 1806 + { 1807 1807 + .name = "last_cmd_status", 1808 1808 + .mode = 0444, 1809 1809 + .kf_ops = &rdtgroup_kf_single_ops, 1810 1810 + .seq_show = rdt_last_cmd_status_show, 1811 1811 + .fflags = RFTYPE_TOP_INFO, 1812 1812 + }, 1813 1813 + { 1814 1814 + .name = "num_closids", 1815 1815 + .mode = 0444, 1816 1816 + .kf_ops = &rdtgroup_kf_single_ops, 1817 1817 + .seq_show = rdt_num_closids_show, 1818 1818 + .fflags = RFTYPE_CTRL_INFO, 1819 1819 + }, 1820 1820 + { 1821 1821 + .name = "mon_features", 1822 1822 + .mode = 0444, 1823 1823 + .kf_ops = &rdtgroup_kf_single_ops, 1824 1824 + .seq_show = rdt_mon_features_show, 1825 1825 + .fflags = RFTYPE_MON_INFO, 1826 1826 + }, 1827 1827 + { 1828 1828 + .name = "num_rmids", 1829 1829 + .mode = 0444, 1830 1830 + .kf_ops = &rdtgroup_kf_single_ops, 1831 1831 + .seq_show = rdt_num_rmids_show, 1832 1832 + .fflags = RFTYPE_MON_INFO, 1833 1833 + }, 1834 1834 + { 1835 1835 + .name = "cbm_mask", 1836 1836 + .mode = 0444, 1837 1837 + .kf_ops = &rdtgroup_kf_single_ops, 1838 1838 + .seq_show = rdt_default_ctrl_show, 1839 1839 + .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 1840 1840 + }, 1841 1841 + { 1842 1842 + .name = "min_cbm_bits", 1843 1843 + .mode = 0444, 1844 1844 + .kf_ops = &rdtgroup_kf_single_ops, 1845 1845 + .seq_show = rdt_min_cbm_bits_show, 1846 1846 + .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 1847 1847 + }, 1848 1848 + { 1849 1849 + .name = "shareable_bits", 1850 1850 + .mode = 0444, 1851 1851 + .kf_ops = &rdtgroup_kf_single_ops, 1852 1852 + .seq_show = rdt_shareable_bits_show, 1853 1853 + .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 1854 1854 + }, 1855 1855 + { 1856 1856 + .name = "bit_usage", 1857 1857 + .mode = 0444, 1858 1858 + .kf_ops = &rdtgroup_kf_single_ops, 1859 1859 + .seq_show = rdt_bit_usage_show, 1860 1860 + .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 1861 1861 + }, 1862 1862 + { 1863 1863 + .name = "min_bandwidth", 1864 1864 + .mode = 0444, 1865 1865 + .kf_ops = &rdtgroup_kf_single_ops, 1866 1866 + .seq_show = rdt_min_bw_show, 1867 1867 + .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_MB, 1868 1868 + }, 1869 1869 + { 1870 1870 + .name = "bandwidth_gran", 1871 1871 + .mode = 0444, 1872 1872 + .kf_ops = &rdtgroup_kf_single_ops, 1873 1873 + .seq_show = rdt_bw_gran_show, 1874 1874 + .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_MB, 1875 1875 + }, 1876 1876 + { 1877 1877 + .name = "delay_linear", 1878 1878 + .mode = 0444, 1879 1879 + .kf_ops = &rdtgroup_kf_single_ops, 1880 1880 + .seq_show = rdt_delay_linear_show, 1881 1881 + .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_MB, 1882 1882 + }, 1883 1883 + /* 1884 1884 + * Platform specific which (if any) capabilities are provided by 1885 1885 + * thread_throttle_mode. Defer "fflags" initialization to platform 1886 1886 + * discovery. 1887 1887 + */ 1888 1888 + { 1889 1889 + .name = "thread_throttle_mode", 1890 1890 + .mode = 0444, 1891 1891 + .kf_ops = &rdtgroup_kf_single_ops, 1892 1892 + .seq_show = rdt_thread_throttle_mode_show, 1893 1893 + }, 1894 1894 + { 1895 1895 + .name = "max_threshold_occupancy", 1896 1896 + .mode = 0644, 1897 1897 + .kf_ops = &rdtgroup_kf_single_ops, 1898 1898 + .write = max_threshold_occ_write, 1899 1899 + .seq_show = max_threshold_occ_show, 1900 1900 + .fflags = RFTYPE_MON_INFO | RFTYPE_RES_CACHE, 1901 1901 + }, 1902 1902 + { 1903 1903 + .name = "mbm_total_bytes_config", 1904 1904 + .mode = 0644, 1905 1905 + .kf_ops = &rdtgroup_kf_single_ops, 1906 1906 + .seq_show = mbm_total_bytes_config_show, 1907 1907 + .write = mbm_total_bytes_config_write, 1908 1908 + }, 1909 1909 + { 1910 1910 + .name = "mbm_local_bytes_config", 1911 1911 + .mode = 0644, 1912 1912 + .kf_ops = &rdtgroup_kf_single_ops, 1913 1913 + .seq_show = mbm_local_bytes_config_show, 1914 1914 + .write = mbm_local_bytes_config_write, 1915 1915 + }, 1916 1916 + { 1917 1917 + .name = "cpus", 1918 1918 + .mode = 0644, 1919 1919 + .kf_ops = &rdtgroup_kf_single_ops, 1920 1920 + .write = rdtgroup_cpus_write, 1921 1921 + .seq_show = rdtgroup_cpus_show, 1922 1922 + .fflags = RFTYPE_BASE, 1923 1923 + }, 1924 1924 + { 1925 1925 + .name = "cpus_list", 1926 1926 + .mode = 0644, 1927 1927 + .kf_ops = &rdtgroup_kf_single_ops, 1928 1928 + .write = rdtgroup_cpus_write, 1929 1929 + .seq_show = rdtgroup_cpus_show, 1930 1930 + .flags = RFTYPE_FLAGS_CPUS_LIST, 1931 1931 + .fflags = RFTYPE_BASE, 1932 1932 + }, 1933 1933 + { 1934 1934 + .name = "tasks", 1935 1935 + .mode = 0644, 1936 1936 + .kf_ops = &rdtgroup_kf_single_ops, 1937 1937 + .write = rdtgroup_tasks_write, 1938 1938 + .seq_show = rdtgroup_tasks_show, 1939 1939 + .fflags = RFTYPE_BASE, 1940 1940 + }, 1941 1941 + { 1942 1942 + .name = "mon_hw_id", 1943 1943 + .mode = 0444, 1944 1944 + .kf_ops = &rdtgroup_kf_single_ops, 1945 1945 + .seq_show = rdtgroup_rmid_show, 1946 1946 + .fflags = RFTYPE_MON_BASE | RFTYPE_DEBUG, 1947 1947 + }, 1948 1948 + { 1949 1949 + .name = "schemata", 1950 1950 + .mode = 0644, 1951 1951 + .kf_ops = &rdtgroup_kf_single_ops, 1952 1952 + .write = rdtgroup_schemata_write, 1953 1953 + .seq_show = rdtgroup_schemata_show, 1954 1954 + .fflags = RFTYPE_CTRL_BASE, 1955 1955 + }, 1956 1956 + { 1957 1957 + .name = "mba_MBps_event", 1958 1958 + .mode = 0644, 1959 1959 + .kf_ops = &rdtgroup_kf_single_ops, 1960 1960 + .write = rdtgroup_mba_mbps_event_write, 1961 1961 + .seq_show = rdtgroup_mba_mbps_event_show, 1962 1962 + }, 1963 1963 + { 1964 1964 + .name = "mode", 1965 1965 + .mode = 0644, 1966 1966 + .kf_ops = &rdtgroup_kf_single_ops, 1967 1967 + .write = rdtgroup_mode_write, 1968 1968 + .seq_show = rdtgroup_mode_show, 1969 1969 + .fflags = RFTYPE_CTRL_BASE, 1970 1970 + }, 1971 1971 + { 1972 1972 + .name = "size", 1973 1973 + .mode = 0444, 1974 1974 + .kf_ops = &rdtgroup_kf_single_ops, 1975 1975 + .seq_show = rdtgroup_size_show, 1976 1976 + .fflags = RFTYPE_CTRL_BASE, 1977 1977 + }, 1978 1978 + { 1979 1979 + .name = "sparse_masks", 1980 1980 + .mode = 0444, 1981 1981 + .kf_ops = &rdtgroup_kf_single_ops, 1982 1982 + .seq_show = rdt_has_sparse_bitmasks_show, 1983 1983 + .fflags = RFTYPE_CTRL_INFO | RFTYPE_RES_CACHE, 1984 1984 + }, 1985 1985 + { 1986 1986 + .name = "ctrl_hw_id", 1987 1987 + .mode = 0444, 1988 1988 + .kf_ops = &rdtgroup_kf_single_ops, 1989 1989 + .seq_show = rdtgroup_closid_show, 1990 1990 + .fflags = RFTYPE_CTRL_BASE | RFTYPE_DEBUG, 1991 1991 + }, 1992 1992 + }; 1993 1993 + 1994 1994 + static int rdtgroup_add_files(struct kernfs_node *kn, unsigned long fflags) 1995 1995 + { 1996 1996 + struct rftype *rfts, *rft; 1997 1997 + int ret, len; 1998 1998 + 1999 1999 + rfts = res_common_files; 2000 2000 + len = ARRAY_SIZE(res_common_files); 2001 2001 + 2002 2002 + lockdep_assert_held(&rdtgroup_mutex); 2003 2003 + 2004 2004 + if (resctrl_debug) 2005 2005 + fflags |= RFTYPE_DEBUG; 2006 2006 + 2007 2007 + for (rft = rfts; rft < rfts + len; rft++) { 2008 2008 + if (rft->fflags && ((fflags & rft->fflags) == rft->fflags)) { 2009 2009 + ret = rdtgroup_add_file(kn, rft); 2010 2010 + if (ret) 2011 2011 + goto error; 2012 2012 + } 2013 2013 + } 2014 2014 + 2015 2015 + return 0; 2016 2016 + error: 2017 2017 + pr_warn("Failed to add %s, err=%d\n", rft->name, ret); 2018 2018 + while (--rft >= rfts) { 2019 2019 + if ((fflags & rft->fflags) == rft->fflags) 2020 2020 + kernfs_remove_by_name(kn, rft->name); 2021 2021 + } 2022 2022 + return ret; 2023 2023 + } 2024 2024 + 2025 2025 + static struct rftype *rdtgroup_get_rftype_by_name(const char *name) 2026 2026 + { 2027 2027 + struct rftype *rfts, *rft; 2028 2028 + int len; 2029 2029 + 2030 2030 + rfts = res_common_files; 2031 2031 + len = ARRAY_SIZE(res_common_files); 2032 2032 + 2033 2033 + for (rft = rfts; rft < rfts + len; rft++) { 2034 2034 + if (!strcmp(rft->name, name)) 2035 2035 + return rft; 2036 2036 + } 2037 2037 + 2038 2038 + return NULL; 2039 2039 + } 2040 2040 + 2041 2041 + static void thread_throttle_mode_init(void) 2042 2042 + { 2043 2043 + enum membw_throttle_mode throttle_mode = THREAD_THROTTLE_UNDEFINED; 2044 2044 + struct rdt_resource *r_mba, *r_smba; 2045 2045 + 2046 2046 + r_mba = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 2047 2047 + if (r_mba->alloc_capable && 2048 2048 + r_mba->membw.throttle_mode != THREAD_THROTTLE_UNDEFINED) 2049 2049 + throttle_mode = r_mba->membw.throttle_mode; 2050 2050 + 2051 2051 + r_smba = resctrl_arch_get_resource(RDT_RESOURCE_SMBA); 2052 2052 + if (r_smba->alloc_capable && 2053 2053 + r_smba->membw.throttle_mode != THREAD_THROTTLE_UNDEFINED) 2054 2054 + throttle_mode = r_smba->membw.throttle_mode; 2055 2055 + 2056 2056 + if (throttle_mode == THREAD_THROTTLE_UNDEFINED) 2057 2057 + return; 2058 2058 + 2059 2059 + resctrl_file_fflags_init("thread_throttle_mode", 2060 2060 + RFTYPE_CTRL_INFO | RFTYPE_RES_MB); 2061 2061 + } 2062 2062 + 2063 2063 + void resctrl_file_fflags_init(const char *config, unsigned long fflags) 2064 2064 + { 2065 2065 + struct rftype *rft; 2066 2066 + 2067 2067 + rft = rdtgroup_get_rftype_by_name(config); 2068 2068 + if (rft) 2069 2069 + rft->fflags = fflags; 2070 2070 + } 2071 2071 + 2072 2072 + /** 2073 2073 + * rdtgroup_kn_mode_restrict - Restrict user access to named resctrl file 2074 2074 + * @r: The resource group with which the file is associated. 2075 2075 + * @name: Name of the file 2076 2076 + * 2077 2077 + * The permissions of named resctrl file, directory, or link are modified 2078 2078 + * to not allow read, write, or execute by any user. 2079 2079 + * 2080 2080 + * WARNING: This function is intended to communicate to the user that the 2081 2081 + * resctrl file has been locked down - that it is not relevant to the 2082 2082 + * particular state the system finds itself in. It should not be relied 2083 2083 + * on to protect from user access because after the file's permissions 2084 2084 + * are restricted the user can still change the permissions using chmod 2085 2085 + * from the command line. 2086 2086 + * 2087 2087 + * Return: 0 on success, <0 on failure. 2088 2088 + */ 2089 2089 + int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name) 2090 2090 + { 2091 2091 + struct iattr iattr = {.ia_valid = ATTR_MODE,}; 2092 2092 + struct kernfs_node *kn; 2093 2093 + int ret = 0; 2094 2094 + 2095 2095 + kn = kernfs_find_and_get_ns(r->kn, name, NULL); 2096 2096 + if (!kn) 2097 2097 + return -ENOENT; 2098 2098 + 2099 2099 + switch (kernfs_type(kn)) { 2100 2100 + case KERNFS_DIR: 2101 2101 + iattr.ia_mode = S_IFDIR; 2102 2102 + break; 2103 2103 + case KERNFS_FILE: 2104 2104 + iattr.ia_mode = S_IFREG; 2105 2105 + break; 2106 2106 + case KERNFS_LINK: 2107 2107 + iattr.ia_mode = S_IFLNK; 2108 2108 + break; 2109 2109 + } 2110 2110 + 2111 2111 + ret = kernfs_setattr(kn, &iattr); 2112 2112 + kernfs_put(kn); 2113 2113 + return ret; 2114 2114 + } 2115 2115 + 2116 2116 + /** 2117 2117 + * rdtgroup_kn_mode_restore - Restore user access to named resctrl file 2118 2118 + * @r: The resource group with which the file is associated. 2119 2119 + * @name: Name of the file 2120 2120 + * @mask: Mask of permissions that should be restored 2121 2121 + * 2122 2122 + * Restore the permissions of the named file. If @name is a directory the 2123 2123 + * permissions of its parent will be used. 2124 2124 + * 2125 2125 + * Return: 0 on success, <0 on failure. 2126 2126 + */ 2127 2127 + int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, 2128 2128 + umode_t mask) 2129 2129 + { 2130 2130 + struct iattr iattr = {.ia_valid = ATTR_MODE,}; 2131 2131 + struct kernfs_node *kn, *parent; 2132 2132 + struct rftype *rfts, *rft; 2133 2133 + int ret, len; 2134 2134 + 2135 2135 + rfts = res_common_files; 2136 2136 + len = ARRAY_SIZE(res_common_files); 2137 2137 + 2138 2138 + for (rft = rfts; rft < rfts + len; rft++) { 2139 2139 + if (!strcmp(rft->name, name)) 2140 2140 + iattr.ia_mode = rft->mode & mask; 2141 2141 + } 2142 2142 + 2143 2143 + kn = kernfs_find_and_get_ns(r->kn, name, NULL); 2144 2144 + if (!kn) 2145 2145 + return -ENOENT; 2146 2146 + 2147 2147 + switch (kernfs_type(kn)) { 2148 2148 + case KERNFS_DIR: 2149 2149 + parent = kernfs_get_parent(kn); 2150 2150 + if (parent) { 2151 2151 + iattr.ia_mode |= parent->mode; 2152 2152 + kernfs_put(parent); 2153 2153 + } 2154 2154 + iattr.ia_mode |= S_IFDIR; 2155 2155 + break; 2156 2156 + case KERNFS_FILE: 2157 2157 + iattr.ia_mode |= S_IFREG; 2158 2158 + break; 2159 2159 + case KERNFS_LINK: 2160 2160 + iattr.ia_mode |= S_IFLNK; 2161 2161 + break; 2162 2162 + } 2163 2163 + 2164 2164 + ret = kernfs_setattr(kn, &iattr); 2165 2165 + kernfs_put(kn); 2166 2166 + return ret; 2167 2167 + } 2168 2168 + 2169 2169 + static int rdtgroup_mkdir_info_resdir(void *priv, char *name, 2170 2170 + unsigned long fflags) 2171 2171 + { 2172 2172 + struct kernfs_node *kn_subdir; 2173 2173 + int ret; 2174 2174 + 2175 2175 + kn_subdir = kernfs_create_dir(kn_info, name, 2176 2176 + kn_info->mode, priv); 2177 2177 + if (IS_ERR(kn_subdir)) 2178 2178 + return PTR_ERR(kn_subdir); 2179 2179 + 2180 2180 + ret = rdtgroup_kn_set_ugid(kn_subdir); 2181 2181 + if (ret) 2182 2182 + return ret; 2183 2183 + 2184 2184 + ret = rdtgroup_add_files(kn_subdir, fflags); 2185 2185 + if (!ret) 2186 2186 + kernfs_activate(kn_subdir); 2187 2187 + 2188 2188 + return ret; 2189 2189 + } 2190 2190 + 2191 2191 + static unsigned long fflags_from_resource(struct rdt_resource *r) 2192 2192 + { 2193 2193 + switch (r->rid) { 2194 2194 + case RDT_RESOURCE_L3: 2195 2195 + case RDT_RESOURCE_L2: 2196 2196 + return RFTYPE_RES_CACHE; 2197 2197 + case RDT_RESOURCE_MBA: 2198 2198 + case RDT_RESOURCE_SMBA: 2199 2199 + return RFTYPE_RES_MB; 2200 2200 + } 2201 2201 + 2202 2202 + return WARN_ON_ONCE(1); 2203 2203 + } 2204 2204 + 2205 2205 + static int rdtgroup_create_info_dir(struct kernfs_node *parent_kn) 2206 2206 + { 2207 2207 + struct resctrl_schema *s; 2208 2208 + struct rdt_resource *r; 2209 2209 + unsigned long fflags; 2210 2210 + char name[32]; 2211 2211 + int ret; 2212 2212 + 2213 2213 + /* create the directory */ 2214 2214 + kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL); 2215 2215 + if (IS_ERR(kn_info)) 2216 2216 + return PTR_ERR(kn_info); 2217 2217 + 2218 2218 + ret = rdtgroup_add_files(kn_info, RFTYPE_TOP_INFO); 2219 2219 + if (ret) 2220 2220 + goto out_destroy; 2221 2221 + 2222 2222 + /* loop over enabled controls, these are all alloc_capable */ 2223 2223 + list_for_each_entry(s, &resctrl_schema_all, list) { 2224 2224 + r = s->res; 2225 2225 + fflags = fflags_from_resource(r) | RFTYPE_CTRL_INFO; 2226 2226 + ret = rdtgroup_mkdir_info_resdir(s, s->name, fflags); 2227 2227 + if (ret) 2228 2228 + goto out_destroy; 2229 2229 + } 2230 2230 + 2231 2231 + for_each_mon_capable_rdt_resource(r) { 2232 2232 + fflags = fflags_from_resource(r) | RFTYPE_MON_INFO; 2233 2233 + sprintf(name, "%s_MON", r->name); 2234 2234 + ret = rdtgroup_mkdir_info_resdir(r, name, fflags); 2235 2235 + if (ret) 2236 2236 + goto out_destroy; 2237 2237 + } 2238 2238 + 2239 2239 + ret = rdtgroup_kn_set_ugid(kn_info); 2240 2240 + if (ret) 2241 2241 + goto out_destroy; 2242 2242 + 2243 2243 + kernfs_activate(kn_info); 2244 2244 + 2245 2245 + return 0; 2246 2246 + 2247 2247 + out_destroy: 2248 2248 + kernfs_remove(kn_info); 2249 2249 + return ret; 2250 2250 + } 2251 2251 + 2252 2252 + static int 2253 2253 + mongroup_create_dir(struct kernfs_node *parent_kn, struct rdtgroup *prgrp, 2254 2254 + char *name, struct kernfs_node **dest_kn) 2255 2255 + { 2256 2256 + struct kernfs_node *kn; 2257 2257 + int ret; 2258 2258 + 2259 2259 + /* create the directory */ 2260 2260 + kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 2261 2261 + if (IS_ERR(kn)) 2262 2262 + return PTR_ERR(kn); 2263 2263 + 2264 2264 + if (dest_kn) 2265 2265 + *dest_kn = kn; 2266 2266 + 2267 2267 + ret = rdtgroup_kn_set_ugid(kn); 2268 2268 + if (ret) 2269 2269 + goto out_destroy; 2270 2270 + 2271 2271 + kernfs_activate(kn); 2272 2272 + 2273 2273 + return 0; 2274 2274 + 2275 2275 + out_destroy: 2276 2276 + kernfs_remove(kn); 2277 2277 + return ret; 2278 2278 + } 2279 2279 + 2280 2280 + static inline bool is_mba_linear(void) 2281 2281 + { 2282 2282 + return resctrl_arch_get_resource(RDT_RESOURCE_MBA)->membw.delay_linear; 2283 2283 + } 2284 2284 + 2285 2285 + static int mba_sc_domain_allocate(struct rdt_resource *r, struct rdt_ctrl_domain *d) 2286 2286 + { 2287 2287 + u32 num_closid = resctrl_arch_get_num_closid(r); 2288 2288 + int cpu = cpumask_any(&d->hdr.cpu_mask); 2289 2289 + int i; 2290 2290 + 2291 2291 + d->mbps_val = kcalloc_node(num_closid, sizeof(*d->mbps_val), 2292 2292 + GFP_KERNEL, cpu_to_node(cpu)); 2293 2293 + if (!d->mbps_val) 2294 2294 + return -ENOMEM; 2295 2295 + 2296 2296 + for (i = 0; i < num_closid; i++) 2297 2297 + d->mbps_val[i] = MBA_MAX_MBPS; 2298 2298 + 2299 2299 + return 0; 2300 2300 + } 2301 2301 + 2302 2302 + static void mba_sc_domain_destroy(struct rdt_resource *r, 2303 2303 + struct rdt_ctrl_domain *d) 2304 2304 + { 2305 2305 + kfree(d->mbps_val); 2306 2306 + d->mbps_val = NULL; 2307 2307 + } 2308 2308 + 2309 2309 + /* 2310 2310 + * MBA software controller is supported only if 2311 2311 + * MBM is supported and MBA is in linear scale, 2312 2312 + * and the MBM monitor scope is the same as MBA 2313 2313 + * control scope. 2314 2314 + */ 2315 2315 + static bool supports_mba_mbps(void) 2316 2316 + { 2317 2317 + struct rdt_resource *rmbm = resctrl_arch_get_resource(RDT_RESOURCE_L3); 2318 2318 + struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 2319 2319 + 2320 2320 + return (resctrl_is_mbm_enabled() && 2321 2321 + r->alloc_capable && is_mba_linear() && 2322 2322 + r->ctrl_scope == rmbm->mon_scope); 2323 2323 + } 2324 2324 + 2325 2325 + /* 2326 2326 + * Enable or disable the MBA software controller 2327 2327 + * which helps user specify bandwidth in MBps. 2328 2328 + */ 2329 2329 + static int set_mba_sc(bool mba_sc) 2330 2330 + { 2331 2331 + struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_MBA); 2332 2332 + u32 num_closid = resctrl_arch_get_num_closid(r); 2333 2333 + struct rdt_ctrl_domain *d; 2334 2334 + unsigned long fflags; 2335 2335 + int i; 2336 2336 + 2337 2337 + if (!supports_mba_mbps() || mba_sc == is_mba_sc(r)) 2338 2338 + return -EINVAL; 2339 2339 + 2340 2340 + r->membw.mba_sc = mba_sc; 2341 2341 + 2342 2342 + rdtgroup_default.mba_mbps_event = mba_mbps_default_event; 2343 2343 + 2344 2344 + list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 2345 2345 + for (i = 0; i < num_closid; i++) 2346 2346 + d->mbps_val[i] = MBA_MAX_MBPS; 2347 2347 + } 2348 2348 + 2349 2349 + fflags = mba_sc ? RFTYPE_CTRL_BASE | RFTYPE_MON_BASE : 0; 2350 2350 + resctrl_file_fflags_init("mba_MBps_event", fflags); 2351 2351 + 2352 2352 + return 0; 2353 2353 + } 2354 2354 + 2355 2355 + /* 2356 2356 + * We don't allow rdtgroup directories to be created anywhere 2357 2357 + * except the root directory. Thus when looking for the rdtgroup 2358 2358 + * structure for a kernfs node we are either looking at a directory, 2359 2359 + * in which case the rdtgroup structure is pointed at by the "priv" 2360 2360 + * field, otherwise we have a file, and need only look to the parent 2361 2361 + * to find the rdtgroup. 2362 2362 + */ 2363 2363 + static struct rdtgroup *kernfs_to_rdtgroup(struct kernfs_node *kn) 2364 2364 + { 2365 2365 + if (kernfs_type(kn) == KERNFS_DIR) { 2366 2366 + /* 2367 2367 + * All the resource directories use "kn->priv" 2368 2368 + * to point to the "struct rdtgroup" for the 2369 2369 + * resource. "info" and its subdirectories don't 2370 2370 + * have rdtgroup structures, so return NULL here. 2371 2371 + */ 2372 2372 + if (kn == kn_info || 2373 2373 + rcu_access_pointer(kn->__parent) == kn_info) 2374 2374 + return NULL; 2375 2375 + else 2376 2376 + return kn->priv; 2377 2377 + } else { 2378 2378 + return rdt_kn_parent_priv(kn); 2379 2379 + } 2380 2380 + } 2381 2381 + 2382 2382 + static void rdtgroup_kn_get(struct rdtgroup *rdtgrp, struct kernfs_node *kn) 2383 2383 + { 2384 2384 + atomic_inc(&rdtgrp->waitcount); 2385 2385 + kernfs_break_active_protection(kn); 2386 2386 + } 2387 2387 + 2388 2388 + static void rdtgroup_kn_put(struct rdtgroup *rdtgrp, struct kernfs_node *kn) 2389 2389 + { 2390 2390 + if (atomic_dec_and_test(&rdtgrp->waitcount) && 2391 2391 + (rdtgrp->flags & RDT_DELETED)) { 2392 2392 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2393 2393 + rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2394 2394 + rdtgroup_pseudo_lock_remove(rdtgrp); 2395 2395 + kernfs_unbreak_active_protection(kn); 2396 2396 + rdtgroup_remove(rdtgrp); 2397 2397 + } else { 2398 2398 + kernfs_unbreak_active_protection(kn); 2399 2399 + } 2400 2400 + } 2401 2401 + 2402 2402 + struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn) 2403 2403 + { 2404 2404 + struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2405 2405 + 2406 2406 + if (!rdtgrp) 2407 2407 + return NULL; 2408 2408 + 2409 2409 + rdtgroup_kn_get(rdtgrp, kn); 2410 2410 + 2411 2411 + cpus_read_lock(); 2412 2412 + mutex_lock(&rdtgroup_mutex); 2413 2413 + 2414 2414 + /* Was this group deleted while we waited? */ 2415 2415 + if (rdtgrp->flags & RDT_DELETED) 2416 2416 + return NULL; 2417 2417 + 2418 2418 + return rdtgrp; 2419 2419 + } 2420 2420 + 2421 2421 + void rdtgroup_kn_unlock(struct kernfs_node *kn) 2422 2422 + { 2423 2423 + struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn); 2424 2424 + 2425 2425 + if (!rdtgrp) 2426 2426 + return; 2427 2427 + 2428 2428 + mutex_unlock(&rdtgroup_mutex); 2429 2429 + cpus_read_unlock(); 2430 2430 + 2431 2431 + rdtgroup_kn_put(rdtgrp, kn); 2432 2432 + } 2433 2433 + 2434 2434 + static int mkdir_mondata_all(struct kernfs_node *parent_kn, 2435 2435 + struct rdtgroup *prgrp, 2436 2436 + struct kernfs_node **mon_data_kn); 2437 2437 + 2438 2438 + static void rdt_disable_ctx(void) 2439 2439 + { 2440 2440 + resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, false); 2441 2441 + resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, false); 2442 2442 + set_mba_sc(false); 2443 2443 + 2444 2444 + resctrl_debug = false; 2445 2445 + } 2446 2446 + 2447 2447 + static int rdt_enable_ctx(struct rdt_fs_context *ctx) 2448 2448 + { 2449 2449 + int ret = 0; 2450 2450 + 2451 2451 + if (ctx->enable_cdpl2) { 2452 2452 + ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, true); 2453 2453 + if (ret) 2454 2454 + goto out_done; 2455 2455 + } 2456 2456 + 2457 2457 + if (ctx->enable_cdpl3) { 2458 2458 + ret = resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, true); 2459 2459 + if (ret) 2460 2460 + goto out_cdpl2; 2461 2461 + } 2462 2462 + 2463 2463 + if (ctx->enable_mba_mbps) { 2464 2464 + ret = set_mba_sc(true); 2465 2465 + if (ret) 2466 2466 + goto out_cdpl3; 2467 2467 + } 2468 2468 + 2469 2469 + if (ctx->enable_debug) 2470 2470 + resctrl_debug = true; 2471 2471 + 2472 2472 + return 0; 2473 2473 + 2474 2474 + out_cdpl3: 2475 2475 + resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L3, false); 2476 2476 + out_cdpl2: 2477 2477 + resctrl_arch_set_cdp_enabled(RDT_RESOURCE_L2, false); 2478 2478 + out_done: 2479 2479 + return ret; 2480 2480 + } 2481 2481 + 2482 2482 + static int schemata_list_add(struct rdt_resource *r, enum resctrl_conf_type type) 2483 2483 + { 2484 2484 + struct resctrl_schema *s; 2485 2485 + const char *suffix = ""; 2486 2486 + int ret, cl; 2487 2487 + 2488 2488 + s = kzalloc(sizeof(*s), GFP_KERNEL); 2489 2489 + if (!s) 2490 2490 + return -ENOMEM; 2491 2491 + 2492 2492 + s->res = r; 2493 2493 + s->num_closid = resctrl_arch_get_num_closid(r); 2494 2494 + if (resctrl_arch_get_cdp_enabled(r->rid)) 2495 2495 + s->num_closid /= 2; 2496 2496 + 2497 2497 + s->conf_type = type; 2498 2498 + switch (type) { 2499 2499 + case CDP_CODE: 2500 2500 + suffix = "CODE"; 2501 2501 + break; 2502 2502 + case CDP_DATA: 2503 2503 + suffix = "DATA"; 2504 2504 + break; 2505 2505 + case CDP_NONE: 2506 2506 + suffix = ""; 2507 2507 + break; 2508 2508 + } 2509 2509 + 2510 2510 + ret = snprintf(s->name, sizeof(s->name), "%s%s", r->name, suffix); 2511 2511 + if (ret >= sizeof(s->name)) { 2512 2512 + kfree(s); 2513 2513 + return -EINVAL; 2514 2514 + } 2515 2515 + 2516 2516 + cl = strlen(s->name); 2517 2517 + 2518 2518 + /* 2519 2519 + * If CDP is supported by this resource, but not enabled, 2520 2520 + * include the suffix. This ensures the tabular format of the 2521 2521 + * schemata file does not change between mounts of the filesystem. 2522 2522 + */ 2523 2523 + if (r->cdp_capable && !resctrl_arch_get_cdp_enabled(r->rid)) 2524 2524 + cl += 4; 2525 2525 + 2526 2526 + if (cl > max_name_width) 2527 2527 + max_name_width = cl; 2528 2528 + 2529 2529 + switch (r->schema_fmt) { 2530 2530 + case RESCTRL_SCHEMA_BITMAP: 2531 2531 + s->fmt_str = "%d=%x"; 2532 2532 + break; 2533 2533 + case RESCTRL_SCHEMA_RANGE: 2534 2534 + s->fmt_str = "%d=%u"; 2535 2535 + break; 2536 2536 + } 2537 2537 + 2538 2538 + if (WARN_ON_ONCE(!s->fmt_str)) { 2539 2539 + kfree(s); 2540 2540 + return -EINVAL; 2541 2541 + } 2542 2542 + 2543 2543 + INIT_LIST_HEAD(&s->list); 2544 2544 + list_add(&s->list, &resctrl_schema_all); 2545 2545 + 2546 2546 + return 0; 2547 2547 + } 2548 2548 + 2549 2549 + static int schemata_list_create(void) 2550 2550 + { 2551 2551 + struct rdt_resource *r; 2552 2552 + int ret = 0; 2553 2553 + 2554 2554 + for_each_alloc_capable_rdt_resource(r) { 2555 2555 + if (resctrl_arch_get_cdp_enabled(r->rid)) { 2556 2556 + ret = schemata_list_add(r, CDP_CODE); 2557 2557 + if (ret) 2558 2558 + break; 2559 2559 + 2560 2560 + ret = schemata_list_add(r, CDP_DATA); 2561 2561 + } else { 2562 2562 + ret = schemata_list_add(r, CDP_NONE); 2563 2563 + } 2564 2564 + 2565 2565 + if (ret) 2566 2566 + break; 2567 2567 + } 2568 2568 + 2569 2569 + return ret; 2570 2570 + } 2571 2571 + 2572 2572 + static void schemata_list_destroy(void) 2573 2573 + { 2574 2574 + struct resctrl_schema *s, *tmp; 2575 2575 + 2576 2576 + list_for_each_entry_safe(s, tmp, &resctrl_schema_all, list) { 2577 2577 + list_del(&s->list); 2578 2578 + kfree(s); 2579 2579 + } 2580 2580 + } 2581 2581 + 2582 2582 + static int rdt_get_tree(struct fs_context *fc) 2583 2583 + { 2584 2584 + struct rdt_fs_context *ctx = rdt_fc2context(fc); 2585 2585 + unsigned long flags = RFTYPE_CTRL_BASE; 2586 2586 + struct rdt_mon_domain *dom; 2587 2587 + struct rdt_resource *r; 2588 2588 + int ret; 2589 2589 + 2590 2590 + cpus_read_lock(); 2591 2591 + mutex_lock(&rdtgroup_mutex); 2592 2592 + /* 2593 2593 + * resctrl file system can only be mounted once. 2594 2594 + */ 2595 2595 + if (resctrl_mounted) { 2596 2596 + ret = -EBUSY; 2597 2597 + goto out; 2598 2598 + } 2599 2599 + 2600 2600 + ret = rdtgroup_setup_root(ctx); 2601 2601 + if (ret) 2602 2602 + goto out; 2603 2603 + 2604 2604 + ret = rdt_enable_ctx(ctx); 2605 2605 + if (ret) 2606 2606 + goto out_root; 2607 2607 + 2608 2608 + ret = schemata_list_create(); 2609 2609 + if (ret) { 2610 2610 + schemata_list_destroy(); 2611 2611 + goto out_ctx; 2612 2612 + } 2613 2613 + 2614 2614 + ret = closid_init(); 2615 2615 + if (ret) 2616 2616 + goto out_schemata_free; 2617 2617 + 2618 2618 + if (resctrl_arch_mon_capable()) 2619 2619 + flags |= RFTYPE_MON; 2620 2620 + 2621 2621 + ret = rdtgroup_add_files(rdtgroup_default.kn, flags); 2622 2622 + if (ret) 2623 2623 + goto out_closid_exit; 2624 2624 + 2625 2625 + kernfs_activate(rdtgroup_default.kn); 2626 2626 + 2627 2627 + ret = rdtgroup_create_info_dir(rdtgroup_default.kn); 2628 2628 + if (ret < 0) 2629 2629 + goto out_closid_exit; 2630 2630 + 2631 2631 + if (resctrl_arch_mon_capable()) { 2632 2632 + ret = mongroup_create_dir(rdtgroup_default.kn, 2633 2633 + &rdtgroup_default, "mon_groups", 2634 2634 + &kn_mongrp); 2635 2635 + if (ret < 0) 2636 2636 + goto out_info; 2637 2637 + 2638 2638 + ret = mkdir_mondata_all(rdtgroup_default.kn, 2639 2639 + &rdtgroup_default, &kn_mondata); 2640 2640 + if (ret < 0) 2641 2641 + goto out_mongrp; 2642 2642 + rdtgroup_default.mon.mon_data_kn = kn_mondata; 2643 2643 + } 2644 2644 + 2645 2645 + ret = rdt_pseudo_lock_init(); 2646 2646 + if (ret) 2647 2647 + goto out_mondata; 2648 2648 + 2649 2649 + ret = kernfs_get_tree(fc); 2650 2650 + if (ret < 0) 2651 2651 + goto out_psl; 2652 2652 + 2653 2653 + if (resctrl_arch_alloc_capable()) 2654 2654 + resctrl_arch_enable_alloc(); 2655 2655 + if (resctrl_arch_mon_capable()) 2656 2656 + resctrl_arch_enable_mon(); 2657 2657 + 2658 2658 + if (resctrl_arch_alloc_capable() || resctrl_arch_mon_capable()) 2659 2659 + resctrl_mounted = true; 2660 2660 + 2661 2661 + if (resctrl_is_mbm_enabled()) { 2662 2662 + r = resctrl_arch_get_resource(RDT_RESOURCE_L3); 2663 2663 + list_for_each_entry(dom, &r->mon_domains, hdr.list) 2664 2664 + mbm_setup_overflow_handler(dom, MBM_OVERFLOW_INTERVAL, 2665 2665 + RESCTRL_PICK_ANY_CPU); 2666 2666 + } 2667 2667 + 2668 2668 + goto out; 2669 2669 + 2670 2670 + out_psl: 2671 2671 + rdt_pseudo_lock_release(); 2672 2672 + out_mondata: 2673 2673 + if (resctrl_arch_mon_capable()) 2674 2674 + kernfs_remove(kn_mondata); 2675 2675 + out_mongrp: 2676 2676 + if (resctrl_arch_mon_capable()) 2677 2677 + kernfs_remove(kn_mongrp); 2678 2678 + out_info: 2679 2679 + kernfs_remove(kn_info); 2680 2680 + out_closid_exit: 2681 2681 + closid_exit(); 2682 2682 + out_schemata_free: 2683 2683 + schemata_list_destroy(); 2684 2684 + out_ctx: 2685 2685 + rdt_disable_ctx(); 2686 2686 + out_root: 2687 2687 + rdtgroup_destroy_root(); 2688 2688 + out: 2689 2689 + rdt_last_cmd_clear(); 2690 2690 + mutex_unlock(&rdtgroup_mutex); 2691 2691 + cpus_read_unlock(); 2692 2692 + return ret; 2693 2693 + } 2694 2694 + 2695 2695 + enum rdt_param { 2696 2696 + Opt_cdp, 2697 2697 + Opt_cdpl2, 2698 2698 + Opt_mba_mbps, 2699 2699 + Opt_debug, 2700 2700 + nr__rdt_params 2701 2701 + }; 2702 2702 + 2703 2703 + static const struct fs_parameter_spec rdt_fs_parameters[] = { 2704 2704 + fsparam_flag("cdp", Opt_cdp), 2705 2705 + fsparam_flag("cdpl2", Opt_cdpl2), 2706 2706 + fsparam_flag("mba_MBps", Opt_mba_mbps), 2707 2707 + fsparam_flag("debug", Opt_debug), 2708 2708 + {} 2709 2709 + }; 2710 2710 + 2711 2711 + static int rdt_parse_param(struct fs_context *fc, struct fs_parameter *param) 2712 2712 + { 2713 2713 + struct rdt_fs_context *ctx = rdt_fc2context(fc); 2714 2714 + struct fs_parse_result result; 2715 2715 + const char *msg; 2716 2716 + int opt; 2717 2717 + 2718 2718 + opt = fs_parse(fc, rdt_fs_parameters, param, &result); 2719 2719 + if (opt < 0) 2720 2720 + return opt; 2721 2721 + 2722 2722 + switch (opt) { 2723 2723 + case Opt_cdp: 2724 2724 + ctx->enable_cdpl3 = true; 2725 2725 + return 0; 2726 2726 + case Opt_cdpl2: 2727 2727 + ctx->enable_cdpl2 = true; 2728 2728 + return 0; 2729 2729 + case Opt_mba_mbps: 2730 2730 + msg = "mba_MBps requires MBM and linear scale MBA at L3 scope"; 2731 2731 + if (!supports_mba_mbps()) 2732 2732 + return invalfc(fc, msg); 2733 2733 + ctx->enable_mba_mbps = true; 2734 2734 + return 0; 2735 2735 + case Opt_debug: 2736 2736 + ctx->enable_debug = true; 2737 2737 + return 0; 2738 2738 + } 2739 2739 + 2740 2740 + return -EINVAL; 2741 2741 + } 2742 2742 + 2743 2743 + static void rdt_fs_context_free(struct fs_context *fc) 2744 2744 + { 2745 2745 + struct rdt_fs_context *ctx = rdt_fc2context(fc); 2746 2746 + 2747 2747 + kernfs_free_fs_context(fc); 2748 2748 + kfree(ctx); 2749 2749 + } 2750 2750 + 2751 2751 + static const struct fs_context_operations rdt_fs_context_ops = { 2752 2752 + .free = rdt_fs_context_free, 2753 2753 + .parse_param = rdt_parse_param, 2754 2754 + .get_tree = rdt_get_tree, 2755 2755 + }; 2756 2756 + 2757 2757 + static int rdt_init_fs_context(struct fs_context *fc) 2758 2758 + { 2759 2759 + struct rdt_fs_context *ctx; 2760 2760 + 2761 2761 + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 2762 2762 + if (!ctx) 2763 2763 + return -ENOMEM; 2764 2764 + 2765 2765 + ctx->kfc.magic = RDTGROUP_SUPER_MAGIC; 2766 2766 + fc->fs_private = &ctx->kfc; 2767 2767 + fc->ops = &rdt_fs_context_ops; 2768 2768 + put_user_ns(fc->user_ns); 2769 2769 + fc->user_ns = get_user_ns(&init_user_ns); 2770 2770 + fc->global = true; 2771 2771 + return 0; 2772 2772 + } 2773 2773 + 2774 2774 + /* 2775 2775 + * Move tasks from one to the other group. If @from is NULL, then all tasks 2776 2776 + * in the systems are moved unconditionally (used for teardown). 2777 2777 + * 2778 2778 + * If @mask is not NULL the cpus on which moved tasks are running are set 2779 2779 + * in that mask so the update smp function call is restricted to affected 2780 2780 + * cpus. 2781 2781 + */ 2782 2782 + static void rdt_move_group_tasks(struct rdtgroup *from, struct rdtgroup *to, 2783 2783 + struct cpumask *mask) 2784 2784 + { 2785 2785 + struct task_struct *p, *t; 2786 2786 + 2787 2787 + read_lock(&tasklist_lock); 2788 2788 + for_each_process_thread(p, t) { 2789 2789 + if (!from || is_closid_match(t, from) || 2790 2790 + is_rmid_match(t, from)) { 2791 2791 + resctrl_arch_set_closid_rmid(t, to->closid, 2792 2792 + to->mon.rmid); 2793 2793 + 2794 2794 + /* 2795 2795 + * Order the closid/rmid stores above before the loads 2796 2796 + * in task_curr(). This pairs with the full barrier 2797 2797 + * between the rq->curr update and 2798 2798 + * resctrl_arch_sched_in() during context switch. 2799 2799 + */ 2800 2800 + smp_mb(); 2801 2801 + 2802 2802 + /* 2803 2803 + * If the task is on a CPU, set the CPU in the mask. 2804 2804 + * The detection is inaccurate as tasks might move or 2805 2805 + * schedule before the smp function call takes place. 2806 2806 + * In such a case the function call is pointless, but 2807 2807 + * there is no other side effect. 2808 2808 + */ 2809 2809 + if (IS_ENABLED(CONFIG_SMP) && mask && task_curr(t)) 2810 2810 + cpumask_set_cpu(task_cpu(t), mask); 2811 2811 + } 2812 2812 + } 2813 2813 + read_unlock(&tasklist_lock); 2814 2814 + } 2815 2815 + 2816 2816 + static void free_all_child_rdtgrp(struct rdtgroup *rdtgrp) 2817 2817 + { 2818 2818 + struct rdtgroup *sentry, *stmp; 2819 2819 + struct list_head *head; 2820 2820 + 2821 2821 + head = &rdtgrp->mon.crdtgrp_list; 2822 2822 + list_for_each_entry_safe(sentry, stmp, head, mon.crdtgrp_list) { 2823 2823 + free_rmid(sentry->closid, sentry->mon.rmid); 2824 2824 + list_del(&sentry->mon.crdtgrp_list); 2825 2825 + 2826 2826 + if (atomic_read(&sentry->waitcount) != 0) 2827 2827 + sentry->flags = RDT_DELETED; 2828 2828 + else 2829 2829 + rdtgroup_remove(sentry); 2830 2830 + } 2831 2831 + } 2832 2832 + 2833 2833 + /* 2834 2834 + * Forcibly remove all of subdirectories under root. 2835 2835 + */ 2836 2836 + static void rmdir_all_sub(void) 2837 2837 + { 2838 2838 + struct rdtgroup *rdtgrp, *tmp; 2839 2839 + 2840 2840 + /* Move all tasks to the default resource group */ 2841 2841 + rdt_move_group_tasks(NULL, &rdtgroup_default, NULL); 2842 2842 + 2843 2843 + list_for_each_entry_safe(rdtgrp, tmp, &rdt_all_groups, rdtgroup_list) { 2844 2844 + /* Free any child rmids */ 2845 2845 + free_all_child_rdtgrp(rdtgrp); 2846 2846 + 2847 2847 + /* Remove each rdtgroup other than root */ 2848 2848 + if (rdtgrp == &rdtgroup_default) 2849 2849 + continue; 2850 2850 + 2851 2851 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 2852 2852 + rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) 2853 2853 + rdtgroup_pseudo_lock_remove(rdtgrp); 2854 2854 + 2855 2855 + /* 2856 2856 + * Give any CPUs back to the default group. We cannot copy 2857 2857 + * cpu_online_mask because a CPU might have executed the 2858 2858 + * offline callback already, but is still marked online. 2859 2859 + */ 2860 2860 + cpumask_or(&rdtgroup_default.cpu_mask, 2861 2861 + &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 2862 2862 + 2863 2863 + free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 2864 2864 + 2865 2865 + kernfs_remove(rdtgrp->kn); 2866 2866 + list_del(&rdtgrp->rdtgroup_list); 2867 2867 + 2868 2868 + if (atomic_read(&rdtgrp->waitcount) != 0) 2869 2869 + rdtgrp->flags = RDT_DELETED; 2870 2870 + else 2871 2871 + rdtgroup_remove(rdtgrp); 2872 2872 + } 2873 2873 + /* Notify online CPUs to update per cpu storage and PQR_ASSOC MSR */ 2874 2874 + update_closid_rmid(cpu_online_mask, &rdtgroup_default); 2875 2875 + 2876 2876 + kernfs_remove(kn_info); 2877 2877 + kernfs_remove(kn_mongrp); 2878 2878 + kernfs_remove(kn_mondata); 2879 2879 + } 2880 2880 + 2881 2881 + /** 2882 2882 + * mon_get_kn_priv() - Get the mon_data priv data for this event. 2883 2883 + * 2884 2884 + * The same values are used across the mon_data directories of all control and 2885 2885 + * monitor groups for the same event in the same domain. Keep a list of 2886 2886 + * allocated structures and re-use an existing one with the same values for 2887 2887 + * @rid, @domid, etc. 2888 2888 + * 2889 2889 + * @rid: The resource id for the event file being created. 2890 2890 + * @domid: The domain id for the event file being created. 2891 2891 + * @mevt: The type of event file being created. 2892 2892 + * @do_sum: Whether SNC summing monitors are being created. 2893 2893 + */ 2894 2894 + static struct mon_data *mon_get_kn_priv(enum resctrl_res_level rid, int domid, 2895 2895 + struct mon_evt *mevt, 2896 2896 + bool do_sum) 2897 2897 + { 2898 2898 + struct mon_data *priv; 2899 2899 + 2900 2900 + lockdep_assert_held(&rdtgroup_mutex); 2901 2901 + 2902 2902 + list_for_each_entry(priv, &mon_data_kn_priv_list, list) { 2903 2903 + if (priv->rid == rid && priv->domid == domid && 2904 2904 + priv->sum == do_sum && priv->evtid == mevt->evtid) 2905 2905 + return priv; 2906 2906 + } 2907 2907 + 2908 2908 + priv = kzalloc(sizeof(*priv), GFP_KERNEL); 2909 2909 + if (!priv) 2910 2910 + return NULL; 2911 2911 + 2912 2912 + priv->rid = rid; 2913 2913 + priv->domid = domid; 2914 2914 + priv->sum = do_sum; 2915 2915 + priv->evtid = mevt->evtid; 2916 2916 + list_add_tail(&priv->list, &mon_data_kn_priv_list); 2917 2917 + 2918 2918 + return priv; 2919 2919 + } 2920 2920 + 2921 2921 + /** 2922 2922 + * mon_put_kn_priv() - Free all allocated mon_data structures. 2923 2923 + * 2924 2924 + * Called when resctrl file system is unmounted. 2925 2925 + */ 2926 2926 + static void mon_put_kn_priv(void) 2927 2927 + { 2928 2928 + struct mon_data *priv, *tmp; 2929 2929 + 2930 2930 + lockdep_assert_held(&rdtgroup_mutex); 2931 2931 + 2932 2932 + list_for_each_entry_safe(priv, tmp, &mon_data_kn_priv_list, list) { 2933 2933 + list_del(&priv->list); 2934 2934 + kfree(priv); 2935 2935 + } 2936 2936 + } 2937 2937 + 2938 2938 + static void resctrl_fs_teardown(void) 2939 2939 + { 2940 2940 + lockdep_assert_held(&rdtgroup_mutex); 2941 2941 + 2942 2942 + /* Cleared by rdtgroup_destroy_root() */ 2943 2943 + if (!rdtgroup_default.kn) 2944 2944 + return; 2945 2945 + 2946 2946 + rmdir_all_sub(); 2947 2947 + mon_put_kn_priv(); 2948 2948 + rdt_pseudo_lock_release(); 2949 2949 + rdtgroup_default.mode = RDT_MODE_SHAREABLE; 2950 2950 + closid_exit(); 2951 2951 + schemata_list_destroy(); 2952 2952 + rdtgroup_destroy_root(); 2953 2953 + } 2954 2954 + 2955 2955 + static void rdt_kill_sb(struct super_block *sb) 2956 2956 + { 2957 2957 + struct rdt_resource *r; 2958 2958 + 2959 2959 + cpus_read_lock(); 2960 2960 + mutex_lock(&rdtgroup_mutex); 2961 2961 + 2962 2962 + rdt_disable_ctx(); 2963 2963 + 2964 2964 + /* Put everything back to default values. */ 2965 2965 + for_each_alloc_capable_rdt_resource(r) 2966 2966 + resctrl_arch_reset_all_ctrls(r); 2967 2967 + 2968 2968 + resctrl_fs_teardown(); 2969 2969 + if (resctrl_arch_alloc_capable()) 2970 2970 + resctrl_arch_disable_alloc(); 2971 2971 + if (resctrl_arch_mon_capable()) 2972 2972 + resctrl_arch_disable_mon(); 2973 2973 + resctrl_mounted = false; 2974 2974 + kernfs_kill_sb(sb); 2975 2975 + mutex_unlock(&rdtgroup_mutex); 2976 2976 + cpus_read_unlock(); 2977 2977 + } 2978 2978 + 2979 2979 + static struct file_system_type rdt_fs_type = { 2980 2980 + .name = "resctrl", 2981 2981 + .init_fs_context = rdt_init_fs_context, 2982 2982 + .parameters = rdt_fs_parameters, 2983 2983 + .kill_sb = rdt_kill_sb, 2984 2984 + }; 2985 2985 + 2986 2986 + static int mon_addfile(struct kernfs_node *parent_kn, const char *name, 2987 2987 + void *priv) 2988 2988 + { 2989 2989 + struct kernfs_node *kn; 2990 2990 + int ret = 0; 2991 2991 + 2992 2992 + kn = __kernfs_create_file(parent_kn, name, 0444, 2993 2993 + GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 0, 2994 2994 + &kf_mondata_ops, priv, NULL, NULL); 2995 2995 + if (IS_ERR(kn)) 2996 2996 + return PTR_ERR(kn); 2997 2997 + 2998 2998 + ret = rdtgroup_kn_set_ugid(kn); 2999 2999 + if (ret) { 3000 3000 + kernfs_remove(kn); 3001 3001 + return ret; 3002 3002 + } 3003 3003 + 3004 3004 + return ret; 3005 3005 + } 3006 3006 + 3007 3007 + static void mon_rmdir_one_subdir(struct kernfs_node *pkn, char *name, char *subname) 3008 3008 + { 3009 3009 + struct kernfs_node *kn; 3010 3010 + 3011 3011 + kn = kernfs_find_and_get(pkn, name); 3012 3012 + if (!kn) 3013 3013 + return; 3014 3014 + kernfs_put(kn); 3015 3015 + 3016 3016 + if (kn->dir.subdirs <= 1) 3017 3017 + kernfs_remove(kn); 3018 3018 + else 3019 3019 + kernfs_remove_by_name(kn, subname); 3020 3020 + } 3021 3021 + 3022 3022 + /* 3023 3023 + * Remove all subdirectories of mon_data of ctrl_mon groups 3024 3024 + * and monitor groups for the given domain. 3025 3025 + * Remove files and directories containing "sum" of domain data 3026 3026 + * when last domain being summed is removed. 3027 3027 + */ 3028 3028 + static void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 3029 3029 + struct rdt_mon_domain *d) 3030 3030 + { 3031 3031 + struct rdtgroup *prgrp, *crgrp; 3032 3032 + char subname[32]; 3033 3033 + bool snc_mode; 3034 3034 + char name[32]; 3035 3035 + 3036 3036 + snc_mode = r->mon_scope == RESCTRL_L3_NODE; 3037 3037 + sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci->id : d->hdr.id); 3038 3038 + if (snc_mode) 3039 3039 + sprintf(subname, "mon_sub_%s_%02d", r->name, d->hdr.id); 3040 3040 + 3041 3041 + list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 3042 3042 + mon_rmdir_one_subdir(prgrp->mon.mon_data_kn, name, subname); 3043 3043 + 3044 3044 + list_for_each_entry(crgrp, &prgrp->mon.crdtgrp_list, mon.crdtgrp_list) 3045 3045 + mon_rmdir_one_subdir(crgrp->mon.mon_data_kn, name, subname); 3046 3046 + } 3047 3047 + } 3048 3048 + 3049 3049 + static int mon_add_all_files(struct kernfs_node *kn, struct rdt_mon_domain *d, 3050 3050 + struct rdt_resource *r, struct rdtgroup *prgrp, 3051 3051 + bool do_sum) 3052 3052 + { 3053 3053 + struct rmid_read rr = {0}; 3054 3054 + struct mon_data *priv; 3055 3055 + struct mon_evt *mevt; 3056 3056 + int ret, domid; 3057 3057 + 3058 3058 + if (WARN_ON(list_empty(&r->evt_list))) 3059 3059 + return -EPERM; 3060 3060 + 3061 3061 + list_for_each_entry(mevt, &r->evt_list, list) { 3062 3062 + domid = do_sum ? d->ci->id : d->hdr.id; 3063 3063 + priv = mon_get_kn_priv(r->rid, domid, mevt, do_sum); 3064 3064 + if (WARN_ON_ONCE(!priv)) 3065 3065 + return -EINVAL; 3066 3066 + 3067 3067 + ret = mon_addfile(kn, mevt->name, priv); 3068 3068 + if (ret) 3069 3069 + return ret; 3070 3070 + 3071 3071 + if (!do_sum && resctrl_is_mbm_event(mevt->evtid)) 3072 3072 + mon_event_read(&rr, r, d, prgrp, &d->hdr.cpu_mask, mevt->evtid, true); 3073 3073 + } 3074 3074 + 3075 3075 + return 0; 3076 3076 + } 3077 3077 + 3078 3078 + static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, 3079 3079 + struct rdt_mon_domain *d, 3080 3080 + struct rdt_resource *r, struct rdtgroup *prgrp) 3081 3081 + { 3082 3082 + struct kernfs_node *kn, *ckn; 3083 3083 + char name[32]; 3084 3084 + bool snc_mode; 3085 3085 + int ret = 0; 3086 3086 + 3087 3087 + lockdep_assert_held(&rdtgroup_mutex); 3088 3088 + 3089 3089 + snc_mode = r->mon_scope == RESCTRL_L3_NODE; 3090 3090 + sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci->id : d->hdr.id); 3091 3091 + kn = kernfs_find_and_get(parent_kn, name); 3092 3092 + if (kn) { 3093 3093 + /* 3094 3094 + * rdtgroup_mutex will prevent this directory from being 3095 3095 + * removed. No need to keep this hold. 3096 3096 + */ 3097 3097 + kernfs_put(kn); 3098 3098 + } else { 3099 3099 + kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); 3100 3100 + if (IS_ERR(kn)) 3101 3101 + return PTR_ERR(kn); 3102 3102 + 3103 3103 + ret = rdtgroup_kn_set_ugid(kn); 3104 3104 + if (ret) 3105 3105 + goto out_destroy; 3106 3106 + ret = mon_add_all_files(kn, d, r, prgrp, snc_mode); 3107 3107 + if (ret) 3108 3108 + goto out_destroy; 3109 3109 + } 3110 3110 + 3111 3111 + if (snc_mode) { 3112 3112 + sprintf(name, "mon_sub_%s_%02d", r->name, d->hdr.id); 3113 3113 + ckn = kernfs_create_dir(kn, name, parent_kn->mode, prgrp); 3114 3114 + if (IS_ERR(ckn)) { 3115 3115 + ret = -EINVAL; 3116 3116 + goto out_destroy; 3117 3117 + } 3118 3118 + 3119 3119 + ret = rdtgroup_kn_set_ugid(ckn); 3120 3120 + if (ret) 3121 3121 + goto out_destroy; 3122 3122 + 3123 3123 + ret = mon_add_all_files(ckn, d, r, prgrp, false); 3124 3124 + if (ret) 3125 3125 + goto out_destroy; 3126 3126 + } 3127 3127 + 3128 3128 + kernfs_activate(kn); 3129 3129 + return 0; 3130 3130 + 3131 3131 + out_destroy: 3132 3132 + kernfs_remove(kn); 3133 3133 + return ret; 3134 3134 + } 3135 3135 + 3136 3136 + /* 3137 3137 + * Add all subdirectories of mon_data for "ctrl_mon" groups 3138 3138 + * and "monitor" groups with given domain id. 3139 3139 + */ 3140 3140 + static void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, 3141 3141 + struct rdt_mon_domain *d) 3142 3142 + { 3143 3143 + struct kernfs_node *parent_kn; 3144 3144 + struct rdtgroup *prgrp, *crgrp; 3145 3145 + struct list_head *head; 3146 3146 + 3147 3147 + list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) { 3148 3148 + parent_kn = prgrp->mon.mon_data_kn; 3149 3149 + mkdir_mondata_subdir(parent_kn, d, r, prgrp); 3150 3150 + 3151 3151 + head = &prgrp->mon.crdtgrp_list; 3152 3152 + list_for_each_entry(crgrp, head, mon.crdtgrp_list) { 3153 3153 + parent_kn = crgrp->mon.mon_data_kn; 3154 3154 + mkdir_mondata_subdir(parent_kn, d, r, crgrp); 3155 3155 + } 3156 3156 + } 3157 3157 + } 3158 3158 + 3159 3159 + static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, 3160 3160 + struct rdt_resource *r, 3161 3161 + struct rdtgroup *prgrp) 3162 3162 + { 3163 3163 + struct rdt_mon_domain *dom; 3164 3164 + int ret; 3165 3165 + 3166 3166 + /* Walking r->domains, ensure it can't race with cpuhp */ 3167 3167 + lockdep_assert_cpus_held(); 3168 3168 + 3169 3169 + list_for_each_entry(dom, &r->mon_domains, hdr.list) { 3170 3170 + ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp); 3171 3171 + if (ret) 3172 3172 + return ret; 3173 3173 + } 3174 3174 + 3175 3175 + return 0; 3176 3176 + } 3177 3177 + 3178 3178 + /* 3179 3179 + * This creates a directory mon_data which contains the monitored data. 3180 3180 + * 3181 3181 + * mon_data has one directory for each domain which are named 3182 3182 + * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data 3183 3183 + * with L3 domain looks as below: 3184 3184 + * ./mon_data: 3185 3185 + * mon_L3_00 3186 3186 + * mon_L3_01 3187 3187 + * mon_L3_02 3188 3188 + * ... 3189 3189 + * 3190 3190 + * Each domain directory has one file per event: 3191 3191 + * ./mon_L3_00/: 3192 3192 + * llc_occupancy 3193 3193 + * 3194 3194 + */ 3195 3195 + static int mkdir_mondata_all(struct kernfs_node *parent_kn, 3196 3196 + struct rdtgroup *prgrp, 3197 3197 + struct kernfs_node **dest_kn) 3198 3198 + { 3199 3199 + struct rdt_resource *r; 3200 3200 + struct kernfs_node *kn; 3201 3201 + int ret; 3202 3202 + 3203 3203 + /* 3204 3204 + * Create the mon_data directory first. 3205 3205 + */ 3206 3206 + ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn); 3207 3207 + if (ret) 3208 3208 + return ret; 3209 3209 + 3210 3210 + if (dest_kn) 3211 3211 + *dest_kn = kn; 3212 3212 + 3213 3213 + /* 3214 3214 + * Create the subdirectories for each domain. Note that all events 3215 3215 + * in a domain like L3 are grouped into a resource whose domain is L3 3216 3216 + */ 3217 3217 + for_each_mon_capable_rdt_resource(r) { 3218 3218 + ret = mkdir_mondata_subdir_alldom(kn, r, prgrp); 3219 3219 + if (ret) 3220 3220 + goto out_destroy; 3221 3221 + } 3222 3222 + 3223 3223 + return 0; 3224 3224 + 3225 3225 + out_destroy: 3226 3226 + kernfs_remove(kn); 3227 3227 + return ret; 3228 3228 + } 3229 3229 + 3230 3230 + /** 3231 3231 + * cbm_ensure_valid - Enforce validity on provided CBM 3232 3232 + * @_val: Candidate CBM 3233 3233 + * @r: RDT resource to which the CBM belongs 3234 3234 + * 3235 3235 + * The provided CBM represents all cache portions available for use. This 3236 3236 + * may be represented by a bitmap that does not consist of contiguous ones 3237 3237 + * and thus be an invalid CBM. 3238 3238 + * Here the provided CBM is forced to be a valid CBM by only considering 3239 3239 + * the first set of contiguous bits as valid and clearing all bits. 3240 3240 + * The intention here is to provide a valid default CBM with which a new 3241 3241 + * resource group is initialized. The user can follow this with a 3242 3242 + * modification to the CBM if the default does not satisfy the 3243 3243 + * requirements. 3244 3244 + */ 3245 3245 + static u32 cbm_ensure_valid(u32 _val, struct rdt_resource *r) 3246 3246 + { 3247 3247 + unsigned int cbm_len = r->cache.cbm_len; 3248 3248 + unsigned long first_bit, zero_bit; 3249 3249 + unsigned long val = _val; 3250 3250 + 3251 3251 + if (!val) 3252 3252 + return 0; 3253 3253 + 3254 3254 + first_bit = find_first_bit(&val, cbm_len); 3255 3255 + zero_bit = find_next_zero_bit(&val, cbm_len, first_bit); 3256 3256 + 3257 3257 + /* Clear any remaining bits to ensure contiguous region */ 3258 3258 + bitmap_clear(&val, zero_bit, cbm_len - zero_bit); 3259 3259 + return (u32)val; 3260 3260 + } 3261 3261 + 3262 3262 + /* 3263 3263 + * Initialize cache resources per RDT domain 3264 3264 + * 3265 3265 + * Set the RDT domain up to start off with all usable allocations. That is, 3266 3266 + * all shareable and unused bits. All-zero CBM is invalid. 3267 3267 + */ 3268 3268 + static int __init_one_rdt_domain(struct rdt_ctrl_domain *d, struct resctrl_schema *s, 3269 3269 + u32 closid) 3270 3270 + { 3271 3271 + enum resctrl_conf_type peer_type = resctrl_peer_type(s->conf_type); 3272 3272 + enum resctrl_conf_type t = s->conf_type; 3273 3273 + struct resctrl_staged_config *cfg; 3274 3274 + struct rdt_resource *r = s->res; 3275 3275 + u32 used_b = 0, unused_b = 0; 3276 3276 + unsigned long tmp_cbm; 3277 3277 + enum rdtgrp_mode mode; 3278 3278 + u32 peer_ctl, ctrl_val; 3279 3279 + int i; 3280 3280 + 3281 3281 + cfg = &d->staged_config[t]; 3282 3282 + cfg->have_new_ctrl = false; 3283 3283 + cfg->new_ctrl = r->cache.shareable_bits; 3284 3284 + used_b = r->cache.shareable_bits; 3285 3285 + for (i = 0; i < closids_supported(); i++) { 3286 3286 + if (closid_allocated(i) && i != closid) { 3287 3287 + mode = rdtgroup_mode_by_closid(i); 3288 3288 + if (mode == RDT_MODE_PSEUDO_LOCKSETUP) 3289 3289 + /* 3290 3290 + * ctrl values for locksetup aren't relevant 3291 3291 + * until the schemata is written, and the mode 3292 3292 + * becomes RDT_MODE_PSEUDO_LOCKED. 3293 3293 + */ 3294 3294 + continue; 3295 3295 + /* 3296 3296 + * If CDP is active include peer domain's 3297 3297 + * usage to ensure there is no overlap 3298 3298 + * with an exclusive group. 3299 3299 + */ 3300 3300 + if (resctrl_arch_get_cdp_enabled(r->rid)) 3301 3301 + peer_ctl = resctrl_arch_get_config(r, d, i, 3302 3302 + peer_type); 3303 3303 + else 3304 3304 + peer_ctl = 0; 3305 3305 + ctrl_val = resctrl_arch_get_config(r, d, i, 3306 3306 + s->conf_type); 3307 3307 + used_b |= ctrl_val | peer_ctl; 3308 3308 + if (mode == RDT_MODE_SHAREABLE) 3309 3309 + cfg->new_ctrl |= ctrl_val | peer_ctl; 3310 3310 + } 3311 3311 + } 3312 3312 + if (d->plr && d->plr->cbm > 0) 3313 3313 + used_b |= d->plr->cbm; 3314 3314 + unused_b = used_b ^ (BIT_MASK(r->cache.cbm_len) - 1); 3315 3315 + unused_b &= BIT_MASK(r->cache.cbm_len) - 1; 3316 3316 + cfg->new_ctrl |= unused_b; 3317 3317 + /* 3318 3318 + * Force the initial CBM to be valid, user can 3319 3319 + * modify the CBM based on system availability. 3320 3320 + */ 3321 3321 + cfg->new_ctrl = cbm_ensure_valid(cfg->new_ctrl, r); 3322 3322 + /* 3323 3323 + * Assign the u32 CBM to an unsigned long to ensure that 3324 3324 + * bitmap_weight() does not access out-of-bound memory. 3325 3325 + */ 3326 3326 + tmp_cbm = cfg->new_ctrl; 3327 3327 + if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) { 3328 3328 + rdt_last_cmd_printf("No space on %s:%d\n", s->name, d->hdr.id); 3329 3329 + return -ENOSPC; 3330 3330 + } 3331 3331 + cfg->have_new_ctrl = true; 3332 3332 + 3333 3333 + return 0; 3334 3334 + } 3335 3335 + 3336 3336 + /* 3337 3337 + * Initialize cache resources with default values. 3338 3338 + * 3339 3339 + * A new RDT group is being created on an allocation capable (CAT) 3340 3340 + * supporting system. Set this group up to start off with all usable 3341 3341 + * allocations. 3342 3342 + * 3343 3343 + * If there are no more shareable bits available on any domain then 3344 3344 + * the entire allocation will fail. 3345 3345 + */ 3346 3346 + static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) 3347 3347 + { 3348 3348 + struct rdt_ctrl_domain *d; 3349 3349 + int ret; 3350 3350 + 3351 3351 + list_for_each_entry(d, &s->res->ctrl_domains, hdr.list) { 3352 3352 + ret = __init_one_rdt_domain(d, s, closid); 3353 3353 + if (ret < 0) 3354 3354 + return ret; 3355 3355 + } 3356 3356 + 3357 3357 + return 0; 3358 3358 + } 3359 3359 + 3360 3360 + /* Initialize MBA resource with default values. */ 3361 3361 + static void rdtgroup_init_mba(struct rdt_resource *r, u32 closid) 3362 3362 + { 3363 3363 + struct resctrl_staged_config *cfg; 3364 3364 + struct rdt_ctrl_domain *d; 3365 3365 + 3366 3366 + list_for_each_entry(d, &r->ctrl_domains, hdr.list) { 3367 3367 + if (is_mba_sc(r)) { 3368 3368 + d->mbps_val[closid] = MBA_MAX_MBPS; 3369 3369 + continue; 3370 3370 + } 3371 3371 + 3372 3372 + cfg = &d->staged_config[CDP_NONE]; 3373 3373 + cfg->new_ctrl = resctrl_get_default_ctrl(r); 3374 3374 + cfg->have_new_ctrl = true; 3375 3375 + } 3376 3376 + } 3377 3377 + 3378 3378 + /* Initialize the RDT group's allocations. */ 3379 3379 + static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp) 3380 3380 + { 3381 3381 + struct resctrl_schema *s; 3382 3382 + struct rdt_resource *r; 3383 3383 + int ret = 0; 3384 3384 + 3385 3385 + rdt_staged_configs_clear(); 3386 3386 + 3387 3387 + list_for_each_entry(s, &resctrl_schema_all, list) { 3388 3388 + r = s->res; 3389 3389 + if (r->rid == RDT_RESOURCE_MBA || 3390 3390 + r->rid == RDT_RESOURCE_SMBA) { 3391 3391 + rdtgroup_init_mba(r, rdtgrp->closid); 3392 3392 + if (is_mba_sc(r)) 3393 3393 + continue; 3394 3394 + } else { 3395 3395 + ret = rdtgroup_init_cat(s, rdtgrp->closid); 3396 3396 + if (ret < 0) 3397 3397 + goto out; 3398 3398 + } 3399 3399 + 3400 3400 + ret = resctrl_arch_update_domains(r, rdtgrp->closid); 3401 3401 + if (ret < 0) { 3402 3402 + rdt_last_cmd_puts("Failed to initialize allocations\n"); 3403 3403 + goto out; 3404 3404 + } 3405 3405 + } 3406 3406 + 3407 3407 + rdtgrp->mode = RDT_MODE_SHAREABLE; 3408 3408 + 3409 3409 + out: 3410 3410 + rdt_staged_configs_clear(); 3411 3411 + return ret; 3412 3412 + } 3413 3413 + 3414 3414 + static int mkdir_rdt_prepare_rmid_alloc(struct rdtgroup *rdtgrp) 3415 3415 + { 3416 3416 + int ret; 3417 3417 + 3418 3418 + if (!resctrl_arch_mon_capable()) 3419 3419 + return 0; 3420 3420 + 3421 3421 + ret = alloc_rmid(rdtgrp->closid); 3422 3422 + if (ret < 0) { 3423 3423 + rdt_last_cmd_puts("Out of RMIDs\n"); 3424 3424 + return ret; 3425 3425 + } 3426 3426 + rdtgrp->mon.rmid = ret; 3427 3427 + 3428 3428 + ret = mkdir_mondata_all(rdtgrp->kn, rdtgrp, &rdtgrp->mon.mon_data_kn); 3429 3429 + if (ret) { 3430 3430 + rdt_last_cmd_puts("kernfs subdir error\n"); 3431 3431 + free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 3432 3432 + return ret; 3433 3433 + } 3434 3434 + 3435 3435 + return 0; 3436 3436 + } 3437 3437 + 3438 3438 + static void mkdir_rdt_prepare_rmid_free(struct rdtgroup *rgrp) 3439 3439 + { 3440 3440 + if (resctrl_arch_mon_capable()) 3441 3441 + free_rmid(rgrp->closid, rgrp->mon.rmid); 3442 3442 + } 3443 3443 + 3444 3444 + /* 3445 3445 + * We allow creating mon groups only with in a directory called "mon_groups" 3446 3446 + * which is present in every ctrl_mon group. Check if this is a valid 3447 3447 + * "mon_groups" directory. 3448 3448 + * 3449 3449 + * 1. The directory should be named "mon_groups". 3450 3450 + * 2. The mon group itself should "not" be named "mon_groups". 3451 3451 + * This makes sure "mon_groups" directory always has a ctrl_mon group 3452 3452 + * as parent. 3453 3453 + */ 3454 3454 + static bool is_mon_groups(struct kernfs_node *kn, const char *name) 3455 3455 + { 3456 3456 + return (!strcmp(rdt_kn_name(kn), "mon_groups") && 3457 3457 + strcmp(name, "mon_groups")); 3458 3458 + } 3459 3459 + 3460 3460 + static int mkdir_rdt_prepare(struct kernfs_node *parent_kn, 3461 3461 + const char *name, umode_t mode, 3462 3462 + enum rdt_group_type rtype, struct rdtgroup **r) 3463 3463 + { 3464 3464 + struct rdtgroup *prdtgrp, *rdtgrp; 3465 3465 + unsigned long files = 0; 3466 3466 + struct kernfs_node *kn; 3467 3467 + int ret; 3468 3468 + 3469 3469 + prdtgrp = rdtgroup_kn_lock_live(parent_kn); 3470 3470 + if (!prdtgrp) { 3471 3471 + ret = -ENODEV; 3472 3472 + goto out_unlock; 3473 3473 + } 3474 3474 + 3475 3475 + /* 3476 3476 + * Check that the parent directory for a monitor group is a "mon_groups" 3477 3477 + * directory. 3478 3478 + */ 3479 3479 + if (rtype == RDTMON_GROUP && !is_mon_groups(parent_kn, name)) { 3480 3480 + ret = -EPERM; 3481 3481 + goto out_unlock; 3482 3482 + } 3483 3483 + 3484 3484 + if (rtype == RDTMON_GROUP && 3485 3485 + (prdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 3486 3486 + prdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)) { 3487 3487 + ret = -EINVAL; 3488 3488 + rdt_last_cmd_puts("Pseudo-locking in progress\n"); 3489 3489 + goto out_unlock; 3490 3490 + } 3491 3491 + 3492 3492 + /* allocate the rdtgroup. */ 3493 3493 + rdtgrp = kzalloc(sizeof(*rdtgrp), GFP_KERNEL); 3494 3494 + if (!rdtgrp) { 3495 3495 + ret = -ENOSPC; 3496 3496 + rdt_last_cmd_puts("Kernel out of memory\n"); 3497 3497 + goto out_unlock; 3498 3498 + } 3499 3499 + *r = rdtgrp; 3500 3500 + rdtgrp->mon.parent = prdtgrp; 3501 3501 + rdtgrp->type = rtype; 3502 3502 + INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list); 3503 3503 + 3504 3504 + /* kernfs creates the directory for rdtgrp */ 3505 3505 + kn = kernfs_create_dir(parent_kn, name, mode, rdtgrp); 3506 3506 + if (IS_ERR(kn)) { 3507 3507 + ret = PTR_ERR(kn); 3508 3508 + rdt_last_cmd_puts("kernfs create error\n"); 3509 3509 + goto out_free_rgrp; 3510 3510 + } 3511 3511 + rdtgrp->kn = kn; 3512 3512 + 3513 3513 + /* 3514 3514 + * kernfs_remove() will drop the reference count on "kn" which 3515 3515 + * will free it. But we still need it to stick around for the 3516 3516 + * rdtgroup_kn_unlock(kn) call. Take one extra reference here, 3517 3517 + * which will be dropped by kernfs_put() in rdtgroup_remove(). 3518 3518 + */ 3519 3519 + kernfs_get(kn); 3520 3520 + 3521 3521 + ret = rdtgroup_kn_set_ugid(kn); 3522 3522 + if (ret) { 3523 3523 + rdt_last_cmd_puts("kernfs perm error\n"); 3524 3524 + goto out_destroy; 3525 3525 + } 3526 3526 + 3527 3527 + if (rtype == RDTCTRL_GROUP) { 3528 3528 + files = RFTYPE_BASE | RFTYPE_CTRL; 3529 3529 + if (resctrl_arch_mon_capable()) 3530 3530 + files |= RFTYPE_MON; 3531 3531 + } else { 3532 3532 + files = RFTYPE_BASE | RFTYPE_MON; 3533 3533 + } 3534 3534 + 3535 3535 + ret = rdtgroup_add_files(kn, files); 3536 3536 + if (ret) { 3537 3537 + rdt_last_cmd_puts("kernfs fill error\n"); 3538 3538 + goto out_destroy; 3539 3539 + } 3540 3540 + 3541 3541 + /* 3542 3542 + * The caller unlocks the parent_kn upon success. 3543 3543 + */ 3544 3544 + return 0; 3545 3545 + 3546 3546 + out_destroy: 3547 3547 + kernfs_put(rdtgrp->kn); 3548 3548 + kernfs_remove(rdtgrp->kn); 3549 3549 + out_free_rgrp: 3550 3550 + kfree(rdtgrp); 3551 3551 + out_unlock: 3552 3552 + rdtgroup_kn_unlock(parent_kn); 3553 3553 + return ret; 3554 3554 + } 3555 3555 + 3556 3556 + static void mkdir_rdt_prepare_clean(struct rdtgroup *rgrp) 3557 3557 + { 3558 3558 + kernfs_remove(rgrp->kn); 3559 3559 + rdtgroup_remove(rgrp); 3560 3560 + } 3561 3561 + 3562 3562 + /* 3563 3563 + * Create a monitor group under "mon_groups" directory of a control 3564 3564 + * and monitor group(ctrl_mon). This is a resource group 3565 3565 + * to monitor a subset of tasks and cpus in its parent ctrl_mon group. 3566 3566 + */ 3567 3567 + static int rdtgroup_mkdir_mon(struct kernfs_node *parent_kn, 3568 3568 + const char *name, umode_t mode) 3569 3569 + { 3570 3570 + struct rdtgroup *rdtgrp, *prgrp; 3571 3571 + int ret; 3572 3572 + 3573 3573 + ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTMON_GROUP, &rdtgrp); 3574 3574 + if (ret) 3575 3575 + return ret; 3576 3576 + 3577 3577 + prgrp = rdtgrp->mon.parent; 3578 3578 + rdtgrp->closid = prgrp->closid; 3579 3579 + 3580 3580 + ret = mkdir_rdt_prepare_rmid_alloc(rdtgrp); 3581 3581 + if (ret) { 3582 3582 + mkdir_rdt_prepare_clean(rdtgrp); 3583 3583 + goto out_unlock; 3584 3584 + } 3585 3585 + 3586 3586 + kernfs_activate(rdtgrp->kn); 3587 3587 + 3588 3588 + /* 3589 3589 + * Add the rdtgrp to the list of rdtgrps the parent 3590 3590 + * ctrl_mon group has to track. 3591 3591 + */ 3592 3592 + list_add_tail(&rdtgrp->mon.crdtgrp_list, &prgrp->mon.crdtgrp_list); 3593 3593 + 3594 3594 + out_unlock: 3595 3595 + rdtgroup_kn_unlock(parent_kn); 3596 3596 + return ret; 3597 3597 + } 3598 3598 + 3599 3599 + /* 3600 3600 + * These are rdtgroups created under the root directory. Can be used 3601 3601 + * to allocate and monitor resources. 3602 3602 + */ 3603 3603 + static int rdtgroup_mkdir_ctrl_mon(struct kernfs_node *parent_kn, 3604 3604 + const char *name, umode_t mode) 3605 3605 + { 3606 3606 + struct rdtgroup *rdtgrp; 3607 3607 + struct kernfs_node *kn; 3608 3608 + u32 closid; 3609 3609 + int ret; 3610 3610 + 3611 3611 + ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTCTRL_GROUP, &rdtgrp); 3612 3612 + if (ret) 3613 3613 + return ret; 3614 3614 + 3615 3615 + kn = rdtgrp->kn; 3616 3616 + ret = closid_alloc(); 3617 3617 + if (ret < 0) { 3618 3618 + rdt_last_cmd_puts("Out of CLOSIDs\n"); 3619 3619 + goto out_common_fail; 3620 3620 + } 3621 3621 + closid = ret; 3622 3622 + ret = 0; 3623 3623 + 3624 3624 + rdtgrp->closid = closid; 3625 3625 + 3626 3626 + ret = mkdir_rdt_prepare_rmid_alloc(rdtgrp); 3627 3627 + if (ret) 3628 3628 + goto out_closid_free; 3629 3629 + 3630 3630 + kernfs_activate(rdtgrp->kn); 3631 3631 + 3632 3632 + ret = rdtgroup_init_alloc(rdtgrp); 3633 3633 + if (ret < 0) 3634 3634 + goto out_rmid_free; 3635 3635 + 3636 3636 + list_add(&rdtgrp->rdtgroup_list, &rdt_all_groups); 3637 3637 + 3638 3638 + if (resctrl_arch_mon_capable()) { 3639 3639 + /* 3640 3640 + * Create an empty mon_groups directory to hold the subset 3641 3641 + * of tasks and cpus to monitor. 3642 3642 + */ 3643 3643 + ret = mongroup_create_dir(kn, rdtgrp, "mon_groups", NULL); 3644 3644 + if (ret) { 3645 3645 + rdt_last_cmd_puts("kernfs subdir error\n"); 3646 3646 + goto out_del_list; 3647 3647 + } 3648 3648 + if (is_mba_sc(NULL)) 3649 3649 + rdtgrp->mba_mbps_event = mba_mbps_default_event; 3650 3650 + } 3651 3651 + 3652 3652 + goto out_unlock; 3653 3653 + 3654 3654 + out_del_list: 3655 3655 + list_del(&rdtgrp->rdtgroup_list); 3656 3656 + out_rmid_free: 3657 3657 + mkdir_rdt_prepare_rmid_free(rdtgrp); 3658 3658 + out_closid_free: 3659 3659 + closid_free(closid); 3660 3660 + out_common_fail: 3661 3661 + mkdir_rdt_prepare_clean(rdtgrp); 3662 3662 + out_unlock: 3663 3663 + rdtgroup_kn_unlock(parent_kn); 3664 3664 + return ret; 3665 3665 + } 3666 3666 + 3667 3667 + static int rdtgroup_mkdir(struct kernfs_node *parent_kn, const char *name, 3668 3668 + umode_t mode) 3669 3669 + { 3670 3670 + /* Do not accept '\n' to avoid unparsable situation. */ 3671 3671 + if (strchr(name, '\n')) 3672 3672 + return -EINVAL; 3673 3673 + 3674 3674 + /* 3675 3675 + * If the parent directory is the root directory and RDT 3676 3676 + * allocation is supported, add a control and monitoring 3677 3677 + * subdirectory 3678 3678 + */ 3679 3679 + if (resctrl_arch_alloc_capable() && parent_kn == rdtgroup_default.kn) 3680 3680 + return rdtgroup_mkdir_ctrl_mon(parent_kn, name, mode); 3681 3681 + 3682 3682 + /* Else, attempt to add a monitoring subdirectory. */ 3683 3683 + if (resctrl_arch_mon_capable()) 3684 3684 + return rdtgroup_mkdir_mon(parent_kn, name, mode); 3685 3685 + 3686 3686 + return -EPERM; 3687 3687 + } 3688 3688 + 3689 3689 + static int rdtgroup_rmdir_mon(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3690 3690 + { 3691 3691 + struct rdtgroup *prdtgrp = rdtgrp->mon.parent; 3692 3692 + u32 closid, rmid; 3693 3693 + int cpu; 3694 3694 + 3695 3695 + /* Give any tasks back to the parent group */ 3696 3696 + rdt_move_group_tasks(rdtgrp, prdtgrp, tmpmask); 3697 3697 + 3698 3698 + /* 3699 3699 + * Update per cpu closid/rmid of the moved CPUs first. 3700 3700 + * Note: the closid will not change, but the arch code still needs it. 3701 3701 + */ 3702 3702 + closid = prdtgrp->closid; 3703 3703 + rmid = prdtgrp->mon.rmid; 3704 3704 + for_each_cpu(cpu, &rdtgrp->cpu_mask) 3705 3705 + resctrl_arch_set_cpu_default_closid_rmid(cpu, closid, rmid); 3706 3706 + 3707 3707 + /* 3708 3708 + * Update the MSR on moved CPUs and CPUs which have moved 3709 3709 + * task running on them. 3710 3710 + */ 3711 3711 + cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3712 3712 + update_closid_rmid(tmpmask, NULL); 3713 3713 + 3714 3714 + rdtgrp->flags = RDT_DELETED; 3715 3715 + free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 3716 3716 + 3717 3717 + /* 3718 3718 + * Remove the rdtgrp from the parent ctrl_mon group's list 3719 3719 + */ 3720 3720 + WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list)); 3721 3721 + list_del(&rdtgrp->mon.crdtgrp_list); 3722 3722 + 3723 3723 + kernfs_remove(rdtgrp->kn); 3724 3724 + 3725 3725 + return 0; 3726 3726 + } 3727 3727 + 3728 3728 + static int rdtgroup_ctrl_remove(struct rdtgroup *rdtgrp) 3729 3729 + { 3730 3730 + rdtgrp->flags = RDT_DELETED; 3731 3731 + list_del(&rdtgrp->rdtgroup_list); 3732 3732 + 3733 3733 + kernfs_remove(rdtgrp->kn); 3734 3734 + return 0; 3735 3735 + } 3736 3736 + 3737 3737 + static int rdtgroup_rmdir_ctrl(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask) 3738 3738 + { 3739 3739 + u32 closid, rmid; 3740 3740 + int cpu; 3741 3741 + 3742 3742 + /* Give any tasks back to the default group */ 3743 3743 + rdt_move_group_tasks(rdtgrp, &rdtgroup_default, tmpmask); 3744 3744 + 3745 3745 + /* Give any CPUs back to the default group */ 3746 3746 + cpumask_or(&rdtgroup_default.cpu_mask, 3747 3747 + &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask); 3748 3748 + 3749 3749 + /* Update per cpu closid and rmid of the moved CPUs first */ 3750 3750 + closid = rdtgroup_default.closid; 3751 3751 + rmid = rdtgroup_default.mon.rmid; 3752 3752 + for_each_cpu(cpu, &rdtgrp->cpu_mask) 3753 3753 + resctrl_arch_set_cpu_default_closid_rmid(cpu, closid, rmid); 3754 3754 + 3755 3755 + /* 3756 3756 + * Update the MSR on moved CPUs and CPUs which have moved 3757 3757 + * task running on them. 3758 3758 + */ 3759 3759 + cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask); 3760 3760 + update_closid_rmid(tmpmask, NULL); 3761 3761 + 3762 3762 + free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); 3763 3763 + closid_free(rdtgrp->closid); 3764 3764 + 3765 3765 + rdtgroup_ctrl_remove(rdtgrp); 3766 3766 + 3767 3767 + /* 3768 3768 + * Free all the child monitor group rmids. 3769 3769 + */ 3770 3770 + free_all_child_rdtgrp(rdtgrp); 3771 3771 + 3772 3772 + return 0; 3773 3773 + } 3774 3774 + 3775 3775 + static struct kernfs_node *rdt_kn_parent(struct kernfs_node *kn) 3776 3776 + { 3777 3777 + /* 3778 3778 + * Valid within the RCU section it was obtained or while rdtgroup_mutex 3779 3779 + * is held. 3780 3780 + */ 3781 3781 + return rcu_dereference_check(kn->__parent, lockdep_is_held(&rdtgroup_mutex)); 3782 3782 + } 3783 3783 + 3784 3784 + static int rdtgroup_rmdir(struct kernfs_node *kn) 3785 3785 + { 3786 3786 + struct kernfs_node *parent_kn; 3787 3787 + struct rdtgroup *rdtgrp; 3788 3788 + cpumask_var_t tmpmask; 3789 3789 + int ret = 0; 3790 3790 + 3791 3791 + if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) 3792 3792 + return -ENOMEM; 3793 3793 + 3794 3794 + rdtgrp = rdtgroup_kn_lock_live(kn); 3795 3795 + if (!rdtgrp) { 3796 3796 + ret = -EPERM; 3797 3797 + goto out; 3798 3798 + } 3799 3799 + parent_kn = rdt_kn_parent(kn); 3800 3800 + 3801 3801 + /* 3802 3802 + * If the rdtgroup is a ctrl_mon group and parent directory 3803 3803 + * is the root directory, remove the ctrl_mon group. 3804 3804 + * 3805 3805 + * If the rdtgroup is a mon group and parent directory 3806 3806 + * is a valid "mon_groups" directory, remove the mon group. 3807 3807 + */ 3808 3808 + if (rdtgrp->type == RDTCTRL_GROUP && parent_kn == rdtgroup_default.kn && 3809 3809 + rdtgrp != &rdtgroup_default) { 3810 3810 + if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP || 3811 3811 + rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) { 3812 3812 + ret = rdtgroup_ctrl_remove(rdtgrp); 3813 3813 + } else { 3814 3814 + ret = rdtgroup_rmdir_ctrl(rdtgrp, tmpmask); 3815 3815 + } 3816 3816 + } else if (rdtgrp->type == RDTMON_GROUP && 3817 3817 + is_mon_groups(parent_kn, rdt_kn_name(kn))) { 3818 3818 + ret = rdtgroup_rmdir_mon(rdtgrp, tmpmask); 3819 3819 + } else { 3820 3820 + ret = -EPERM; 3821 3821 + } 3822 3822 + 3823 3823 + out: 3824 3824 + rdtgroup_kn_unlock(kn); 3825 3825 + free_cpumask_var(tmpmask); 3826 3826 + return ret; 3827 3827 + } 3828 3828 + 3829 3829 + /** 3830 3830 + * mongrp_reparent() - replace parent CTRL_MON group of a MON group 3831 3831 + * @rdtgrp: the MON group whose parent should be replaced 3832 3832 + * @new_prdtgrp: replacement parent CTRL_MON group for @rdtgrp 3833 3833 + * @cpus: cpumask provided by the caller for use during this call 3834 3834 + * 3835 3835 + * Replaces the parent CTRL_MON group for a MON group, resulting in all member 3836 3836 + * tasks' CLOSID immediately changing to that of the new parent group. 3837 3837 + * Monitoring data for the group is unaffected by this operation. 3838 3838 + */ 3839 3839 + static void mongrp_reparent(struct rdtgroup *rdtgrp, 3840 3840 + struct rdtgroup *new_prdtgrp, 3841 3841 + cpumask_var_t cpus) 3842 3842 + { 3843 3843 + struct rdtgroup *prdtgrp = rdtgrp->mon.parent; 3844 3844 + 3845 3845 + WARN_ON(rdtgrp->type != RDTMON_GROUP); 3846 3846 + WARN_ON(new_prdtgrp->type != RDTCTRL_GROUP); 3847 3847 + 3848 3848 + /* Nothing to do when simply renaming a MON group. */ 3849 3849 + if (prdtgrp == new_prdtgrp) 3850 3850 + return; 3851 3851 + 3852 3852 + WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list)); 3853 3853 + list_move_tail(&rdtgrp->mon.crdtgrp_list, 3854 3854 + &new_prdtgrp->mon.crdtgrp_list); 3855 3855 + 3856 3856 + rdtgrp->mon.parent = new_prdtgrp; 3857 3857 + rdtgrp->closid = new_prdtgrp->closid; 3858 3858 + 3859 3859 + /* Propagate updated closid to all tasks in this group. */ 3860 3860 + rdt_move_group_tasks(rdtgrp, rdtgrp, cpus); 3861 3861 + 3862 3862 + update_closid_rmid(cpus, NULL); 3863 3863 + } 3864 3864 + 3865 3865 + static int rdtgroup_rename(struct kernfs_node *kn, 3866 3866 + struct kernfs_node *new_parent, const char *new_name) 3867 3867 + { 3868 3868 + struct kernfs_node *kn_parent; 3869 3869 + struct rdtgroup *new_prdtgrp; 3870 3870 + struct rdtgroup *rdtgrp; 3871 3871 + cpumask_var_t tmpmask; 3872 3872 + int ret; 3873 3873 + 3874 3874 + rdtgrp = kernfs_to_rdtgroup(kn); 3875 3875 + new_prdtgrp = kernfs_to_rdtgroup(new_parent); 3876 3876 + if (!rdtgrp || !new_prdtgrp) 3877 3877 + return -ENOENT; 3878 3878 + 3879 3879 + /* Release both kernfs active_refs before obtaining rdtgroup mutex. */ 3880 3880 + rdtgroup_kn_get(rdtgrp, kn); 3881 3881 + rdtgroup_kn_get(new_prdtgrp, new_parent); 3882 3882 + 3883 3883 + mutex_lock(&rdtgroup_mutex); 3884 3884 + 3885 3885 + rdt_last_cmd_clear(); 3886 3886 + 3887 3887 + /* 3888 3888 + * Don't allow kernfs_to_rdtgroup() to return a parent rdtgroup if 3889 3889 + * either kernfs_node is a file. 3890 3890 + */ 3891 3891 + if (kernfs_type(kn) != KERNFS_DIR || 3892 3892 + kernfs_type(new_parent) != KERNFS_DIR) { 3893 3893 + rdt_last_cmd_puts("Source and destination must be directories"); 3894 3894 + ret = -EPERM; 3895 3895 + goto out; 3896 3896 + } 3897 3897 + 3898 3898 + if ((rdtgrp->flags & RDT_DELETED) || (new_prdtgrp->flags & RDT_DELETED)) { 3899 3899 + ret = -ENOENT; 3900 3900 + goto out; 3901 3901 + } 3902 3902 + 3903 3903 + kn_parent = rdt_kn_parent(kn); 3904 3904 + if (rdtgrp->type != RDTMON_GROUP || !kn_parent || 3905 3905 + !is_mon_groups(kn_parent, rdt_kn_name(kn))) { 3906 3906 + rdt_last_cmd_puts("Source must be a MON group\n"); 3907 3907 + ret = -EPERM; 3908 3908 + goto out; 3909 3909 + } 3910 3910 + 3911 3911 + if (!is_mon_groups(new_parent, new_name)) { 3912 3912 + rdt_last_cmd_puts("Destination must be a mon_groups subdirectory\n"); 3913 3913 + ret = -EPERM; 3914 3914 + goto out; 3915 3915 + } 3916 3916 + 3917 3917 + /* 3918 3918 + * If the MON group is monitoring CPUs, the CPUs must be assigned to the 3919 3919 + * current parent CTRL_MON group and therefore cannot be assigned to 3920 3920 + * the new parent, making the move illegal. 3921 3921 + */ 3922 3922 + if (!cpumask_empty(&rdtgrp->cpu_mask) && 3923 3923 + rdtgrp->mon.parent != new_prdtgrp) { 3924 3924 + rdt_last_cmd_puts("Cannot move a MON group that monitors CPUs\n"); 3925 3925 + ret = -EPERM; 3926 3926 + goto out; 3927 3927 + } 3928 3928 + 3929 3929 + /* 3930 3930 + * Allocate the cpumask for use in mongrp_reparent() to avoid the 3931 3931 + * possibility of failing to allocate it after kernfs_rename() has 3932 3932 + * succeeded. 3933 3933 + */ 3934 3934 + if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL)) { 3935 3935 + ret = -ENOMEM; 3936 3936 + goto out; 3937 3937 + } 3938 3938 + 3939 3939 + /* 3940 3940 + * Perform all input validation and allocations needed to ensure 3941 3941 + * mongrp_reparent() will succeed before calling kernfs_rename(), 3942 3942 + * otherwise it would be necessary to revert this call if 3943 3943 + * mongrp_reparent() failed. 3944 3944 + */ 3945 3945 + ret = kernfs_rename(kn, new_parent, new_name); 3946 3946 + if (!ret) 3947 3947 + mongrp_reparent(rdtgrp, new_prdtgrp, tmpmask); 3948 3948 + 3949 3949 + free_cpumask_var(tmpmask); 3950 3950 + 3951 3951 + out: 3952 3952 + mutex_unlock(&rdtgroup_mutex); 3953 3953 + rdtgroup_kn_put(rdtgrp, kn); 3954 3954 + rdtgroup_kn_put(new_prdtgrp, new_parent); 3955 3955 + return ret; 3956 3956 + } 3957 3957 + 3958 3958 + static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf) 3959 3959 + { 3960 3960 + if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L3)) 3961 3961 + seq_puts(seq, ",cdp"); 3962 3962 + 3963 3963 + if (resctrl_arch_get_cdp_enabled(RDT_RESOURCE_L2)) 3964 3964 + seq_puts(seq, ",cdpl2"); 3965 3965 + 3966 3966 + if (is_mba_sc(resctrl_arch_get_resource(RDT_RESOURCE_MBA))) 3967 3967 + seq_puts(seq, ",mba_MBps"); 3968 3968 + 3969 3969 + if (resctrl_debug) 3970 3970 + seq_puts(seq, ",debug"); 3971 3971 + 3972 3972 + return 0; 3973 3973 + } 3974 3974 + 3975 3975 + static struct kernfs_syscall_ops rdtgroup_kf_syscall_ops = { 3976 3976 + .mkdir = rdtgroup_mkdir, 3977 3977 + .rmdir = rdtgroup_rmdir, 3978 3978 + .rename = rdtgroup_rename, 3979 3979 + .show_options = rdtgroup_show_options, 3980 3980 + }; 3981 3981 + 3982 3982 + static int rdtgroup_setup_root(struct rdt_fs_context *ctx) 3983 3983 + { 3984 3984 + rdt_root = kernfs_create_root(&rdtgroup_kf_syscall_ops, 3985 3985 + KERNFS_ROOT_CREATE_DEACTIVATED | 3986 3986 + KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK, 3987 3987 + &rdtgroup_default); 3988 3988 + if (IS_ERR(rdt_root)) 3989 3989 + return PTR_ERR(rdt_root); 3990 3990 + 3991 3991 + ctx->kfc.root = rdt_root; 3992 3992 + rdtgroup_default.kn = kernfs_root_to_node(rdt_root); 3993 3993 + 3994 3994 + return 0; 3995 3995 + } 3996 3996 + 3997 3997 + static void rdtgroup_destroy_root(void) 3998 3998 + { 3999 3999 + lockdep_assert_held(&rdtgroup_mutex); 4000 4000 + 4001 4001 + kernfs_destroy_root(rdt_root); 4002 4002 + rdtgroup_default.kn = NULL; 4003 4003 + } 4004 4004 + 4005 4005 + static void rdtgroup_setup_default(void) 4006 4006 + { 4007 4007 + mutex_lock(&rdtgroup_mutex); 4008 4008 + 4009 4009 + rdtgroup_default.closid = RESCTRL_RESERVED_CLOSID; 4010 4010 + rdtgroup_default.mon.rmid = RESCTRL_RESERVED_RMID; 4011 4011 + rdtgroup_default.type = RDTCTRL_GROUP; 4012 4012 + INIT_LIST_HEAD(&rdtgroup_default.mon.crdtgrp_list); 4013 4013 + 4014 4014 + list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups); 4015 4015 + 4016 4016 + mutex_unlock(&rdtgroup_mutex); 4017 4017 + } 4018 4018 + 4019 4019 + static void domain_destroy_mon_state(struct rdt_mon_domain *d) 4020 4020 + { 4021 4021 + bitmap_free(d->rmid_busy_llc); 4022 4022 + kfree(d->mbm_total); 4023 4023 + kfree(d->mbm_local); 4024 4024 + } 4025 4025 + 4026 4026 + void resctrl_offline_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d) 4027 4027 + { 4028 4028 + mutex_lock(&rdtgroup_mutex); 4029 4029 + 4030 4030 + if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) 4031 4031 + mba_sc_domain_destroy(r, d); 4032 4032 + 4033 4033 + mutex_unlock(&rdtgroup_mutex); 4034 4034 + } 4035 4035 + 4036 4036 + void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d) 4037 4037 + { 4038 4038 + mutex_lock(&rdtgroup_mutex); 4039 4039 + 4040 4040 + /* 4041 4041 + * If resctrl is mounted, remove all the 4042 4042 + * per domain monitor data directories. 4043 4043 + */ 4044 4044 + if (resctrl_mounted && resctrl_arch_mon_capable()) 4045 4045 + rmdir_mondata_subdir_allrdtgrp(r, d); 4046 4046 + 4047 4047 + if (resctrl_is_mbm_enabled()) 4048 4048 + cancel_delayed_work(&d->mbm_over); 4049 4049 + if (resctrl_arch_is_llc_occupancy_enabled() && has_busy_rmid(d)) { 4050 4050 + /* 4051 4051 + * When a package is going down, forcefully 4052 4052 + * decrement rmid->ebusy. There is no way to know 4053 4053 + * that the L3 was flushed and hence may lead to 4054 4054 + * incorrect counts in rare scenarios, but leaving 4055 4055 + * the RMID as busy creates RMID leaks if the 4056 4056 + * package never comes back. 4057 4057 + */ 4058 4058 + __check_limbo(d, true); 4059 4059 + cancel_delayed_work(&d->cqm_limbo); 4060 4060 + } 4061 4061 + 4062 4062 + domain_destroy_mon_state(d); 4063 4063 + 4064 4064 + mutex_unlock(&rdtgroup_mutex); 4065 4065 + } 4066 4066 + 4067 4067 + /** 4068 4068 + * domain_setup_mon_state() - Initialise domain monitoring structures. 4069 4069 + * @r: The resource for the newly online domain. 4070 4070 + * @d: The newly online domain. 4071 4071 + * 4072 4072 + * Allocate monitor resources that belong to this domain. 4073 4073 + * Called when the first CPU of a domain comes online, regardless of whether 4074 4074 + * the filesystem is mounted. 4075 4075 + * During boot this may be called before global allocations have been made by 4076 4076 + * resctrl_mon_resource_init(). 4077 4077 + * 4078 4078 + * Returns 0 for success, or -ENOMEM. 4079 4079 + */ 4080 4080 + static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_mon_domain *d) 4081 4081 + { 4082 4082 + u32 idx_limit = resctrl_arch_system_num_rmid_idx(); 4083 4083 + size_t tsize; 4084 4084 + 4085 4085 + if (resctrl_arch_is_llc_occupancy_enabled()) { 4086 4086 + d->rmid_busy_llc = bitmap_zalloc(idx_limit, GFP_KERNEL); 4087 4087 + if (!d->rmid_busy_llc) 4088 4088 + return -ENOMEM; 4089 4089 + } 4090 4090 + if (resctrl_arch_is_mbm_total_enabled()) { 4091 4091 + tsize = sizeof(*d->mbm_total); 4092 4092 + d->mbm_total = kcalloc(idx_limit, tsize, GFP_KERNEL); 4093 4093 + if (!d->mbm_total) { 4094 4094 + bitmap_free(d->rmid_busy_llc); 4095 4095 + return -ENOMEM; 4096 4096 + } 4097 4097 + } 4098 4098 + if (resctrl_arch_is_mbm_local_enabled()) { 4099 4099 + tsize = sizeof(*d->mbm_local); 4100 4100 + d->mbm_local = kcalloc(idx_limit, tsize, GFP_KERNEL); 4101 4101 + if (!d->mbm_local) { 4102 4102 + bitmap_free(d->rmid_busy_llc); 4103 4103 + kfree(d->mbm_total); 4104 4104 + return -ENOMEM; 4105 4105 + } 4106 4106 + } 4107 4107 + 4108 4108 + return 0; 4109 4109 + } 4110 4110 + 4111 4111 + int resctrl_online_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d) 4112 4112 + { 4113 4113 + int err = 0; 4114 4114 + 4115 4115 + mutex_lock(&rdtgroup_mutex); 4116 4116 + 4117 4117 + if (supports_mba_mbps() && r->rid == RDT_RESOURCE_MBA) { 4118 4118 + /* RDT_RESOURCE_MBA is never mon_capable */ 4119 4119 + err = mba_sc_domain_allocate(r, d); 4120 4120 + } 4121 4121 + 4122 4122 + mutex_unlock(&rdtgroup_mutex); 4123 4123 + 4124 4124 + return err; 4125 4125 + } 4126 4126 + 4127 4127 + int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d) 4128 4128 + { 4129 4129 + int err; 4130 4130 + 4131 4131 + mutex_lock(&rdtgroup_mutex); 4132 4132 + 4133 4133 + err = domain_setup_mon_state(r, d); 4134 4134 + if (err) 4135 4135 + goto out_unlock; 4136 4136 + 4137 4137 + if (resctrl_is_mbm_enabled()) { 4138 4138 + INIT_DELAYED_WORK(&d->mbm_over, mbm_handle_overflow); 4139 4139 + mbm_setup_overflow_handler(d, MBM_OVERFLOW_INTERVAL, 4140 4140 + RESCTRL_PICK_ANY_CPU); 4141 4141 + } 4142 4142 + 4143 4143 + if (resctrl_arch_is_llc_occupancy_enabled()) 4144 4144 + INIT_DELAYED_WORK(&d->cqm_limbo, cqm_handle_limbo); 4145 4145 + 4146 4146 + /* 4147 4147 + * If the filesystem is not mounted then only the default resource group 4148 4148 + * exists. Creation of its directories is deferred until mount time 4149 4149 + * by rdt_get_tree() calling mkdir_mondata_all(). 4150 4150 + * If resctrl is mounted, add per domain monitor data directories. 4151 4151 + */ 4152 4152 + if (resctrl_mounted && resctrl_arch_mon_capable()) 4153 4153 + mkdir_mondata_subdir_allrdtgrp(r, d); 4154 4154 + 4155 4155 + out_unlock: 4156 4156 + mutex_unlock(&rdtgroup_mutex); 4157 4157 + 4158 4158 + return err; 4159 4159 + } 4160 4160 + 4161 4161 + void resctrl_online_cpu(unsigned int cpu) 4162 4162 + { 4163 4163 + mutex_lock(&rdtgroup_mutex); 4164 4164 + /* The CPU is set in default rdtgroup after online. */ 4165 4165 + cpumask_set_cpu(cpu, &rdtgroup_default.cpu_mask); 4166 4166 + mutex_unlock(&rdtgroup_mutex); 4167 4167 + } 4168 4168 + 4169 4169 + static void clear_childcpus(struct rdtgroup *r, unsigned int cpu) 4170 4170 + { 4171 4171 + struct rdtgroup *cr; 4172 4172 + 4173 4173 + list_for_each_entry(cr, &r->mon.crdtgrp_list, mon.crdtgrp_list) { 4174 4174 + if (cpumask_test_and_clear_cpu(cpu, &cr->cpu_mask)) 4175 4175 + break; 4176 4176 + } 4177 4177 + } 4178 4178 + 4179 4179 + static struct rdt_mon_domain *get_mon_domain_from_cpu(int cpu, 4180 4180 + struct rdt_resource *r) 4181 4181 + { 4182 4182 + struct rdt_mon_domain *d; 4183 4183 + 4184 4184 + lockdep_assert_cpus_held(); 4185 4185 + 4186 4186 + list_for_each_entry(d, &r->mon_domains, hdr.list) { 4187 4187 + /* Find the domain that contains this CPU */ 4188 4188 + if (cpumask_test_cpu(cpu, &d->hdr.cpu_mask)) 4189 4189 + return d; 4190 4190 + } 4191 4191 + 4192 4192 + return NULL; 4193 4193 + } 4194 4194 + 4195 4195 + void resctrl_offline_cpu(unsigned int cpu) 4196 4196 + { 4197 4197 + struct rdt_resource *l3 = resctrl_arch_get_resource(RDT_RESOURCE_L3); 4198 4198 + struct rdt_mon_domain *d; 4199 4199 + struct rdtgroup *rdtgrp; 4200 4200 + 4201 4201 + mutex_lock(&rdtgroup_mutex); 4202 4202 + list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) { 4203 4203 + if (cpumask_test_and_clear_cpu(cpu, &rdtgrp->cpu_mask)) { 4204 4204 + clear_childcpus(rdtgrp, cpu); 4205 4205 + break; 4206 4206 + } 4207 4207 + } 4208 4208 + 4209 4209 + if (!l3->mon_capable) 4210 4210 + goto out_unlock; 4211 4211 + 4212 4212 + d = get_mon_domain_from_cpu(cpu, l3); 4213 4213 + if (d) { 4214 4214 + if (resctrl_is_mbm_enabled() && cpu == d->mbm_work_cpu) { 4215 4215 + cancel_delayed_work(&d->mbm_over); 4216 4216 + mbm_setup_overflow_handler(d, 0, cpu); 4217 4217 + } 4218 4218 + if (resctrl_arch_is_llc_occupancy_enabled() && 4219 4219 + cpu == d->cqm_work_cpu && has_busy_rmid(d)) { 4220 4220 + cancel_delayed_work(&d->cqm_limbo); 4221 4221 + cqm_setup_limbo_handler(d, 0, cpu); 4222 4222 + } 4223 4223 + } 4224 4224 + 4225 4225 + out_unlock: 4226 4226 + mutex_unlock(&rdtgroup_mutex); 4227 4227 + } 4228 4228 + 4229 4229 + /* 4230 4230 + * resctrl_init - resctrl filesystem initialization 4231 4231 + * 4232 4232 + * Setup resctrl file system including set up root, create mount point, 4233 4233 + * register resctrl filesystem, and initialize files under root directory. 4234 4234 + * 4235 4235 + * Return: 0 on success or -errno 4236 4236 + */ 4237 4237 + int resctrl_init(void) 4238 4238 + { 4239 4239 + int ret = 0; 4240 4240 + 4241 4241 + seq_buf_init(&last_cmd_status, last_cmd_status_buf, 4242 4242 + sizeof(last_cmd_status_buf)); 4243 4243 + 4244 4244 + rdtgroup_setup_default(); 4245 4245 + 4246 4246 + thread_throttle_mode_init(); 4247 4247 + 4248 4248 + ret = resctrl_mon_resource_init(); 4249 4249 + if (ret) 4250 4250 + return ret; 4251 4251 + 4252 4252 + ret = sysfs_create_mount_point(fs_kobj, "resctrl"); 4253 4253 + if (ret) { 4254 4254 + resctrl_mon_resource_exit(); 4255 4255 + return ret; 4256 4256 + } 4257 4257 + 4258 4258 + ret = register_filesystem(&rdt_fs_type); 4259 4259 + if (ret) 4260 4260 + goto cleanup_mountpoint; 4261 4261 + 4262 4262 + /* 4263 4263 + * Adding the resctrl debugfs directory here may not be ideal since 4264 4264 + * it would let the resctrl debugfs directory appear on the debugfs 4265 4265 + * filesystem before the resctrl filesystem is mounted. 4266 4266 + * It may also be ok since that would enable debugging of RDT before 4267 4267 + * resctrl is mounted. 4268 4268 + * The reason why the debugfs directory is created here and not in 4269 4269 + * rdt_get_tree() is because rdt_get_tree() takes rdtgroup_mutex and 4270 4270 + * during the debugfs directory creation also &sb->s_type->i_mutex_key 4271 4271 + * (the lockdep class of inode->i_rwsem). Other filesystem 4272 4272 + * interactions (eg. SyS_getdents) have the lock ordering: 4273 4273 + * &sb->s_type->i_mutex_key --> &mm->mmap_lock 4274 4274 + * During mmap(), called with &mm->mmap_lock, the rdtgroup_mutex 4275 4275 + * is taken, thus creating dependency: 4276 4276 + * &mm->mmap_lock --> rdtgroup_mutex for the latter that can cause 4277 4277 + * issues considering the other two lock dependencies. 4278 4278 + * By creating the debugfs directory here we avoid a dependency 4279 4279 + * that may cause deadlock (even though file operations cannot 4280 4280 + * occur until the filesystem is mounted, but I do not know how to 4281 4281 + * tell lockdep that). 4282 4282 + */ 4283 4283 + debugfs_resctrl = debugfs_create_dir("resctrl", NULL); 4284 4284 + 4285 4285 + return 0; 4286 4286 + 4287 4287 + cleanup_mountpoint: 4288 4288 + sysfs_remove_mount_point(fs_kobj, "resctrl"); 4289 4289 + resctrl_mon_resource_exit(); 4290 4290 + 4291 4291 + return ret; 4292 4292 + } 4293 4293 + 4294 4294 + static bool resctrl_online_domains_exist(void) 4295 4295 + { 4296 4296 + struct rdt_resource *r; 4297 4297 + 4298 4298 + /* 4299 4299 + * Only walk capable resources to allow resctrl_arch_get_resource() 4300 4300 + * to return dummy 'not capable' resources. 4301 4301 + */ 4302 4302 + for_each_alloc_capable_rdt_resource(r) { 4303 4303 + if (!list_empty(&r->ctrl_domains)) 4304 4304 + return true; 4305 4305 + } 4306 4306 + 4307 4307 + for_each_mon_capable_rdt_resource(r) { 4308 4308 + if (!list_empty(&r->mon_domains)) 4309 4309 + return true; 4310 4310 + } 4311 4311 + 4312 4312 + return false; 4313 4313 + } 4314 4314 + 4315 4315 + /** 4316 4316 + * resctrl_exit() - Remove the resctrl filesystem and free resources. 4317 4317 + * 4318 4318 + * Called by the architecture code in response to a fatal error. 4319 4319 + * Removes resctrl files and structures from kernfs to prevent further 4320 4320 + * configuration. 4321 4321 + * 4322 4322 + * When called by the architecture code, all CPUs and resctrl domains must be 4323 4323 + * offline. This ensures the limbo and overflow handlers are not scheduled to 4324 4324 + * run, meaning the data structures they access can be freed by 4325 4325 + * resctrl_mon_resource_exit(). 4326 4326 + * 4327 4327 + * After resctrl_exit() returns, the architecture code should return an 4328 4328 + * error from all resctrl_arch_ functions that can do this. 4329 4329 + * resctrl_arch_get_resource() must continue to return struct rdt_resources 4330 4330 + * with the correct rid field to ensure the filesystem can be unmounted. 4331 4331 + */ 4332 4332 + void resctrl_exit(void) 4333 4333 + { 4334 4334 + cpus_read_lock(); 4335 4335 + WARN_ON_ONCE(resctrl_online_domains_exist()); 4336 4336 + 4337 4337 + mutex_lock(&rdtgroup_mutex); 4338 4338 + resctrl_fs_teardown(); 4339 4339 + mutex_unlock(&rdtgroup_mutex); 4340 4340 + 4341 4341 + cpus_read_unlock(); 4342 4342 + 4343 4343 + debugfs_remove_recursive(debugfs_resctrl); 4344 4344 + debugfs_resctrl = NULL; 4345 4345 + unregister_filesystem(&rdt_fs_type); 4346 4346 + 4347 4347 + /* 4348 4348 + * Do not remove the sysfs mount point added by resctrl_init() so that 4349 4349 + * it can be used to umount resctrl. 4350 4350 + */ 4351 4351 + 4352 4352 + resctrl_mon_resource_exit(); 4353 4353 + }

+71 -4

include/linux/cpumask.h

reviewed

··· 179 179 } 180 180 181 181 /** 182 182 + * cpumask_first_andnot - return the first cpu from *srcp1 & ~*srcp2 183 183 + * @srcp1: the first input 184 184 + * @srcp2: the second input 185 185 + * 186 186 + * Return: >= nr_cpu_ids if no such cpu found. 187 187 + */ 188 188 + static __always_inline 189 189 + unsigned int cpumask_first_andnot(const struct cpumask *srcp1, const struct cpumask *srcp2) 190 190 + { 191 191 + return find_first_andnot_bit(cpumask_bits(srcp1), cpumask_bits(srcp2), small_cpumask_bits); 192 192 + } 193 193 + 194 194 + /** 182 195 * cpumask_first_and_and - return the first cpu from *srcp1 & *srcp2 & *srcp3 183 196 * @srcp1: the first input 184 197 * @srcp2: the second input ··· 294 281 if (n != -1) 295 282 cpumask_check(n); 296 283 return find_next_and_bit(cpumask_bits(src1p), cpumask_bits(src2p), 284 284 + small_cpumask_bits, n + 1); 285 285 + } 286 286 + 287 287 + /** 288 288 + * cpumask_next_andnot - get the next cpu in *src1p & ~*src2p 289 289 + * @n: the cpu prior to the place to search (i.e. return will be > @n) 290 290 + * @src1p: the first cpumask pointer 291 291 + * @src2p: the second cpumask pointer 292 292 + * 293 293 + * Return: >= nr_cpu_ids if no further cpus set in both. 294 294 + */ 295 295 + static __always_inline 296 296 + unsigned int cpumask_next_andnot(int n, const struct cpumask *src1p, 297 297 + const struct cpumask *src2p) 298 298 + { 299 299 + /* -1 is a legal arg here. */ 300 300 + if (n != -1) 301 301 + cpumask_check(n); 302 302 + return find_next_andnot_bit(cpumask_bits(src1p), cpumask_bits(src2p), 297 303 small_cpumask_bits, n + 1); 298 304 } 299 305 ··· 445 413 * @cpu: the cpu to ignore. 446 414 * 447 415 * Often used to find any cpu but smp_processor_id() in a mask. 416 416 + * If @cpu == -1, the function is equivalent to cpumask_any(). 448 417 * Return: >= nr_cpu_ids if no cpus set. 449 418 */ 450 419 static __always_inline 451 451 - unsigned int cpumask_any_but(const struct cpumask *mask, unsigned int cpu) 420 420 + unsigned int cpumask_any_but(const struct cpumask *mask, int cpu) 452 421 { 453 422 unsigned int i; 454 423 455 455 - cpumask_check(cpu); 424 424 + /* -1 is a legal arg here. */ 425 425 + if (cpu != -1) 426 426 + cpumask_check(cpu); 427 427 + 456 428 for_each_cpu(i, mask) 457 429 if (i != cpu) 458 430 break; ··· 469 433 * @mask2: the second input cpumask 470 434 * @cpu: the cpu to ignore 471 435 * 436 436 + * If @cpu == -1, the function is equivalent to cpumask_any_and(). 472 437 * Returns >= nr_cpu_ids if no cpus set. 473 438 */ 474 439 static __always_inline 475 440 unsigned int cpumask_any_and_but(const struct cpumask *mask1, 476 441 const struct cpumask *mask2, 477 477 - unsigned int cpu) 442 442 + int cpu) 478 443 { 479 444 unsigned int i; 480 445 481 481 - cpumask_check(cpu); 446 446 + /* -1 is a legal arg here. */ 447 447 + if (cpu != -1) 448 448 + cpumask_check(cpu); 449 449 + 482 450 i = cpumask_first_and(mask1, mask2); 483 451 if (i != cpu) 484 452 return i; 485 453 486 454 return cpumask_next_and(cpu, mask1, mask2); 455 455 + } 456 456 + 457 457 + /** 458 458 + * cpumask_any_andnot_but - pick an arbitrary cpu from *mask1 & ~*mask2, but not this one. 459 459 + * @mask1: the first input cpumask 460 460 + * @mask2: the second input cpumask 461 461 + * @cpu: the cpu to ignore 462 462 + * 463 463 + * If @cpu == -1, the function returns the first matching cpu. 464 464 + * Returns >= nr_cpu_ids if no cpus set. 465 465 + */ 466 466 + static __always_inline 467 467 + unsigned int cpumask_any_andnot_but(const struct cpumask *mask1, 468 468 + const struct cpumask *mask2, 469 469 + int cpu) 470 470 + { 471 471 + unsigned int i; 472 472 + 473 473 + /* -1 is a legal arg here. */ 474 474 + if (cpu != -1) 475 475 + cpumask_check(cpu); 476 476 + 477 477 + i = cpumask_first_andnot(mask1, mask2); 478 478 + if (i != cpu) 479 479 + return i; 480 480 + 481 481 + return cpumask_next_andnot(cpu, mask1, mask2); 487 482 } 488 483 489 484 /**

+25

include/linux/find.h

reviewed

··· 29 29 unsigned long n); 30 30 extern unsigned long _find_first_and_bit(const unsigned long *addr1, 31 31 const unsigned long *addr2, unsigned long size); 32 32 + unsigned long _find_first_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, 33 33 + unsigned long size); 32 34 unsigned long _find_first_and_and_bit(const unsigned long *addr1, const unsigned long *addr2, 33 35 const unsigned long *addr3, unsigned long size); 34 36 extern unsigned long _find_first_zero_bit(const unsigned long *addr, unsigned long size); ··· 348 346 return _find_first_and_bit(addr1, addr2, size); 349 347 } 350 348 #endif 349 349 + 350 350 + /** 351 351 + * find_first_andnot_bit - find the first bit set in 1st memory region and unset in 2nd 352 352 + * @addr1: The first address to base the search on 353 353 + * @addr2: The second address to base the search on 354 354 + * @size: The bitmap size in bits 355 355 + * 356 356 + * Returns the bit number for the first set bit 357 357 + * If no bits are set, returns >= @size. 358 358 + */ 359 359 + static __always_inline 360 360 + unsigned long find_first_andnot_bit(const unsigned long *addr1, 361 361 + const unsigned long *addr2, 362 362 + unsigned long size) 363 363 + { 364 364 + if (small_const_nbits(size)) { 365 365 + unsigned long val = *addr1 & (~*addr2) & GENMASK(size - 1, 0); 366 366 + 367 367 + return val ? __ffs(val) : size; 368 368 + } 369 369 + 370 370 + return _find_first_andnot_bit(addr1, addr2, size); 371 371 + } 351 372 352 373 /** 353 374 * find_first_and_and_bit - find the first set bit in 3 memory regions

+33 -3

include/linux/resctrl.h

reviewed

··· 8 8 #include <linux/pid.h> 9 9 #include <linux/resctrl_types.h> 10 10 11 11 + #ifdef CONFIG_ARCH_HAS_CPU_RESCTRL 12 12 + #include <asm/resctrl.h> 13 13 + #endif 14 14 + 11 15 /* CLOSID, RMID value used by the default control group */ 12 16 #define RESCTRL_RESERVED_CLOSID 0 13 17 #define RESCTRL_RESERVED_RMID 0 ··· 47 43 #define for_each_mon_capable_rdt_resource(r) \ 48 44 for_each_rdt_resource((r)) \ 49 45 if ((r)->mon_capable) 46 46 + 47 47 + enum resctrl_res_level { 48 48 + RDT_RESOURCE_L3, 49 49 + RDT_RESOURCE_L2, 50 50 + RDT_RESOURCE_MBA, 51 51 + RDT_RESOURCE_SMBA, 52 52 + 53 53 + /* Must be the last */ 54 54 + RDT_NUM_RESOURCES, 55 55 + }; 50 56 51 57 /** 52 58 * enum resctrl_conf_type - The type of configuration. ··· 372 358 u32 resctrl_arch_system_num_rmid_idx(void); 373 359 int resctrl_arch_update_domains(struct rdt_resource *r, u32 closid); 374 360 375 375 - __init bool resctrl_arch_is_evt_configurable(enum resctrl_event_id evt); 361 361 + bool resctrl_arch_is_evt_configurable(enum resctrl_event_id evt); 376 362 377 363 /** 378 364 * resctrl_arch_mon_event_config_write() - Write the config for an event. ··· 412 398 return closid * 2; 413 399 } 414 400 } 401 401 + 402 402 + bool resctrl_arch_get_cdp_enabled(enum resctrl_res_level l); 403 403 + int resctrl_arch_set_cdp_enabled(enum resctrl_res_level l, bool enable); 415 404 416 405 /* 417 406 * Update the ctrl_val and apply this config right now. ··· 531 514 extern unsigned int resctrl_rmid_realloc_threshold; 532 515 extern unsigned int resctrl_rmid_realloc_limit; 533 516 534 534 - int __init resctrl_init(void); 535 535 - void __exit resctrl_exit(void); 517 517 + int resctrl_init(void); 518 518 + void resctrl_exit(void); 536 519 520 520 + #ifdef CONFIG_RESCTRL_FS_PSEUDO_LOCK 521 521 + u64 resctrl_arch_get_prefetch_disable_bits(void); 522 522 + int resctrl_arch_pseudo_lock_fn(void *_plr); 523 523 + int resctrl_arch_measure_cycles_lat_fn(void *_plr); 524 524 + int resctrl_arch_measure_l2_residency(void *_plr); 525 525 + int resctrl_arch_measure_l3_residency(void *_plr); 526 526 + #else 527 527 + static inline u64 resctrl_arch_get_prefetch_disable_bits(void) { return 0; } 528 528 + static inline int resctrl_arch_pseudo_lock_fn(void *_plr) { return 0; } 529 529 + static inline int resctrl_arch_measure_cycles_lat_fn(void *_plr) { return 0; } 530 530 + static inline int resctrl_arch_measure_l2_residency(void *_plr) { return 0; } 531 531 + static inline int resctrl_arch_measure_l3_residency(void *_plr) { return 0; } 532 532 + #endif /* CONFIG_RESCTRL_FS_PSEUDO_LOCK */ 537 533 #endif /* _RESCTRL_H */

+6 -10

include/linux/resctrl_types.h

reviewed

··· 7 7 #ifndef __LINUX_RESCTRL_TYPES_H 8 8 #define __LINUX_RESCTRL_TYPES_H 9 9 10 10 + #define MAX_MBA_BW 100u 11 11 + #define MBM_OVERFLOW_INTERVAL 1000 12 12 + 10 13 /* Reads to Local DRAM Memory */ 11 14 #define READS_TO_LOCAL_MEM BIT(0) 12 15 ··· 34 31 /* Max event bits supported */ 35 32 #define MAX_EVT_CONFIG_BITS GENMASK(6, 0) 36 33 37 37 - enum resctrl_res_level { 38 38 - RDT_RESOURCE_L3, 39 39 - RDT_RESOURCE_L2, 40 40 - RDT_RESOURCE_MBA, 41 41 - RDT_RESOURCE_SMBA, 42 42 - 43 43 - /* Must be the last */ 44 44 - RDT_NUM_RESOURCES, 45 45 - }; 46 46 - 47 34 /* 48 35 * Event IDs, the values match those used to program IA32_QM_EVTSEL before 49 36 * reading IA32_QM_CTR on RDT systems. ··· 42 49 QOS_L3_OCCUP_EVENT_ID = 0x01, 43 50 QOS_L3_MBM_TOTAL_EVENT_ID = 0x02, 44 51 QOS_L3_MBM_LOCAL_EVENT_ID = 0x03, 52 52 + 53 53 + /* Must be the last */ 54 54 + QOS_NUM_EVENTS, 45 55 }; 46 56 47 57 #endif /* __LINUX_RESCTRL_TYPES_H */

+11

lib/find_bit.c

reviewed

··· 117 117 #endif 118 118 119 119 /* 120 120 + * Find the first bit set in 1st memory region and unset in 2nd. 121 121 + */ 122 122 + unsigned long _find_first_andnot_bit(const unsigned long *addr1, 123 123 + const unsigned long *addr2, 124 124 + unsigned long size) 125 125 + { 126 126 + return FIND_FIRST_BIT(addr1[idx] & ~addr2[idx], /* nop */, size); 127 127 + } 128 128 + EXPORT_SYMBOL(_find_first_andnot_bit); 129 129 + 130 130 + /* 120 131 * Find the first set bit in three memory regions. 121 132 */ 122 133 unsigned long _find_first_and_and_bit(const unsigned long *addr1,