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