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