1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef _ASM_X86_RESCTRL_INTERNAL_H |
3 | #define _ASM_X86_RESCTRL_INTERNAL_H |
4 | |
5 | #include <linux/resctrl.h> |
6 | #include <linux/sched.h> |
7 | #include <linux/kernfs.h> |
8 | #include <linux/fs_context.h> |
9 | #include <linux/jump_label.h> |
10 | #include <linux/tick.h> |
11 | |
12 | #include <asm/resctrl.h> |
13 | |
14 | #define L3_QOS_CDP_ENABLE 0x01ULL |
15 | |
16 | #define L2_QOS_CDP_ENABLE 0x01ULL |
17 | |
18 | #define CQM_LIMBOCHECK_INTERVAL 1000 |
19 | |
20 | #define MBM_CNTR_WIDTH_BASE 24 |
21 | #define MBM_OVERFLOW_INTERVAL 1000 |
22 | #define MAX_MBA_BW 100u |
23 | #define MBA_IS_LINEAR 0x4 |
24 | #define MBM_CNTR_WIDTH_OFFSET_AMD 20 |
25 | |
26 | #define RMID_VAL_ERROR BIT_ULL(63) |
27 | #define RMID_VAL_UNAVAIL BIT_ULL(62) |
28 | /* |
29 | * With the above fields in use 62 bits remain in MSR_IA32_QM_CTR for |
30 | * data to be returned. The counter width is discovered from the hardware |
31 | * as an offset from MBM_CNTR_WIDTH_BASE. |
32 | */ |
33 | #define MBM_CNTR_WIDTH_OFFSET_MAX (62 - MBM_CNTR_WIDTH_BASE) |
34 | |
35 | /* Reads to Local DRAM Memory */ |
36 | #define READS_TO_LOCAL_MEM BIT(0) |
37 | |
38 | /* Reads to Remote DRAM Memory */ |
39 | #define READS_TO_REMOTE_MEM BIT(1) |
40 | |
41 | /* Non-Temporal Writes to Local Memory */ |
42 | #define NON_TEMP_WRITE_TO_LOCAL_MEM BIT(2) |
43 | |
44 | /* Non-Temporal Writes to Remote Memory */ |
45 | #define NON_TEMP_WRITE_TO_REMOTE_MEM BIT(3) |
46 | |
47 | /* Reads to Local Memory the system identifies as "Slow Memory" */ |
48 | #define READS_TO_LOCAL_S_MEM BIT(4) |
49 | |
50 | /* Reads to Remote Memory the system identifies as "Slow Memory" */ |
51 | #define READS_TO_REMOTE_S_MEM BIT(5) |
52 | |
53 | /* Dirty Victims to All Types of Memory */ |
54 | #define DIRTY_VICTIMS_TO_ALL_MEM BIT(6) |
55 | |
56 | /* Max event bits supported */ |
57 | #define MAX_EVT_CONFIG_BITS GENMASK(6, 0) |
58 | |
59 | /** |
60 | * cpumask_any_housekeeping() - Choose any CPU in @mask, preferring those that |
61 | * aren't marked nohz_full |
62 | * @mask: The mask to pick a CPU from. |
63 | * @exclude_cpu:The CPU to avoid picking. |
64 | * |
65 | * Returns a CPU from @mask, but not @exclude_cpu. If there are housekeeping |
66 | * CPUs that don't use nohz_full, these are preferred. Pass |
67 | * RESCTRL_PICK_ANY_CPU to avoid excluding any CPUs. |
68 | * |
69 | * When a CPU is excluded, returns >= nr_cpu_ids if no CPUs are available. |
70 | */ |
71 | static inline unsigned int |
72 | cpumask_any_housekeeping(const struct cpumask *mask, int exclude_cpu) |
73 | { |
74 | unsigned int cpu, hk_cpu; |
75 | |
76 | if (exclude_cpu == RESCTRL_PICK_ANY_CPU) |
77 | cpu = cpumask_any(mask); |
78 | else |
79 | cpu = cpumask_any_but(mask, cpu: exclude_cpu); |
80 | |
81 | /* Only continue if tick_nohz_full_mask has been initialized. */ |
82 | if (!tick_nohz_full_enabled()) |
83 | return cpu; |
84 | |
85 | /* If the CPU picked isn't marked nohz_full nothing more needs doing. */ |
86 | if (cpu < nr_cpu_ids && !tick_nohz_full_cpu(cpu)) |
87 | return cpu; |
88 | |
89 | /* Try to find a CPU that isn't nohz_full to use in preference */ |
90 | hk_cpu = cpumask_nth_andnot(cpu: 0, srcp1: mask, srcp2: tick_nohz_full_mask); |
91 | if (hk_cpu == exclude_cpu) |
92 | hk_cpu = cpumask_nth_andnot(cpu: 1, srcp1: mask, srcp2: tick_nohz_full_mask); |
93 | |
94 | if (hk_cpu < nr_cpu_ids) |
95 | cpu = hk_cpu; |
96 | |
97 | return cpu; |
98 | } |
99 | |
100 | struct rdt_fs_context { |
101 | struct kernfs_fs_context kfc; |
102 | bool enable_cdpl2; |
103 | bool enable_cdpl3; |
104 | bool enable_mba_mbps; |
105 | bool enable_debug; |
106 | }; |
107 | |
108 | static inline struct rdt_fs_context *rdt_fc2context(struct fs_context *fc) |
109 | { |
110 | struct kernfs_fs_context *kfc = fc->fs_private; |
111 | |
112 | return container_of(kfc, struct rdt_fs_context, kfc); |
113 | } |
114 | |
115 | /** |
116 | * struct mon_evt - Entry in the event list of a resource |
117 | * @evtid: event id |
118 | * @name: name of the event |
119 | * @configurable: true if the event is configurable |
120 | * @list: entry in &rdt_resource->evt_list |
121 | */ |
122 | struct mon_evt { |
123 | enum resctrl_event_id evtid; |
124 | char *name; |
125 | bool configurable; |
126 | struct list_head list; |
127 | }; |
128 | |
129 | /** |
130 | * union mon_data_bits - Monitoring details for each event file |
131 | * @priv: Used to store monitoring event data in @u |
132 | * as kernfs private data |
133 | * @rid: Resource id associated with the event file |
134 | * @evtid: Event id associated with the event file |
135 | * @domid: The domain to which the event file belongs |
136 | * @u: Name of the bit fields struct |
137 | */ |
138 | union mon_data_bits { |
139 | void *priv; |
140 | struct { |
141 | unsigned int rid : 10; |
142 | enum resctrl_event_id evtid : 8; |
143 | unsigned int domid : 14; |
144 | } u; |
145 | }; |
146 | |
147 | struct rmid_read { |
148 | struct rdtgroup *rgrp; |
149 | struct rdt_resource *r; |
150 | struct rdt_domain *d; |
151 | enum resctrl_event_id evtid; |
152 | bool first; |
153 | int err; |
154 | u64 val; |
155 | void *arch_mon_ctx; |
156 | }; |
157 | |
158 | extern unsigned int rdt_mon_features; |
159 | extern struct list_head resctrl_schema_all; |
160 | extern bool resctrl_mounted; |
161 | |
162 | enum rdt_group_type { |
163 | RDTCTRL_GROUP = 0, |
164 | RDTMON_GROUP, |
165 | RDT_NUM_GROUP, |
166 | }; |
167 | |
168 | /** |
169 | * enum rdtgrp_mode - Mode of a RDT resource group |
170 | * @RDT_MODE_SHAREABLE: This resource group allows sharing of its allocations |
171 | * @RDT_MODE_EXCLUSIVE: No sharing of this resource group's allocations allowed |
172 | * @RDT_MODE_PSEUDO_LOCKSETUP: Resource group will be used for Pseudo-Locking |
173 | * @RDT_MODE_PSEUDO_LOCKED: No sharing of this resource group's allocations |
174 | * allowed AND the allocations are Cache Pseudo-Locked |
175 | * @RDT_NUM_MODES: Total number of modes |
176 | * |
177 | * The mode of a resource group enables control over the allowed overlap |
178 | * between allocations associated with different resource groups (classes |
179 | * of service). User is able to modify the mode of a resource group by |
180 | * writing to the "mode" resctrl file associated with the resource group. |
181 | * |
182 | * The "shareable", "exclusive", and "pseudo-locksetup" modes are set by |
183 | * writing the appropriate text to the "mode" file. A resource group enters |
184 | * "pseudo-locked" mode after the schemata is written while the resource |
185 | * group is in "pseudo-locksetup" mode. |
186 | */ |
187 | enum rdtgrp_mode { |
188 | RDT_MODE_SHAREABLE = 0, |
189 | RDT_MODE_EXCLUSIVE, |
190 | RDT_MODE_PSEUDO_LOCKSETUP, |
191 | RDT_MODE_PSEUDO_LOCKED, |
192 | |
193 | /* Must be last */ |
194 | RDT_NUM_MODES, |
195 | }; |
196 | |
197 | /** |
198 | * struct mongroup - store mon group's data in resctrl fs. |
199 | * @mon_data_kn: kernfs node for the mon_data directory |
200 | * @parent: parent rdtgrp |
201 | * @crdtgrp_list: child rdtgroup node list |
202 | * @rmid: rmid for this rdtgroup |
203 | */ |
204 | struct mongroup { |
205 | struct kernfs_node *mon_data_kn; |
206 | struct rdtgroup *parent; |
207 | struct list_head crdtgrp_list; |
208 | u32 rmid; |
209 | }; |
210 | |
211 | /** |
212 | * struct pseudo_lock_region - pseudo-lock region information |
213 | * @s: Resctrl schema for the resource to which this |
214 | * pseudo-locked region belongs |
215 | * @d: RDT domain to which this pseudo-locked region |
216 | * belongs |
217 | * @cbm: bitmask of the pseudo-locked region |
218 | * @lock_thread_wq: waitqueue used to wait on the pseudo-locking thread |
219 | * completion |
220 | * @thread_done: variable used by waitqueue to test if pseudo-locking |
221 | * thread completed |
222 | * @cpu: core associated with the cache on which the setup code |
223 | * will be run |
224 | * @line_size: size of the cache lines |
225 | * @size: size of pseudo-locked region in bytes |
226 | * @kmem: the kernel memory associated with pseudo-locked region |
227 | * @minor: minor number of character device associated with this |
228 | * region |
229 | * @debugfs_dir: pointer to this region's directory in the debugfs |
230 | * filesystem |
231 | * @pm_reqs: Power management QoS requests related to this region |
232 | */ |
233 | struct pseudo_lock_region { |
234 | struct resctrl_schema *s; |
235 | struct rdt_domain *d; |
236 | u32 cbm; |
237 | wait_queue_head_t lock_thread_wq; |
238 | int thread_done; |
239 | int cpu; |
240 | unsigned int line_size; |
241 | unsigned int size; |
242 | void *kmem; |
243 | unsigned int minor; |
244 | struct dentry *debugfs_dir; |
245 | struct list_head pm_reqs; |
246 | }; |
247 | |
248 | /** |
249 | * struct rdtgroup - store rdtgroup's data in resctrl file system. |
250 | * @kn: kernfs node |
251 | * @rdtgroup_list: linked list for all rdtgroups |
252 | * @closid: closid for this rdtgroup |
253 | * @cpu_mask: CPUs assigned to this rdtgroup |
254 | * @flags: status bits |
255 | * @waitcount: how many cpus expect to find this |
256 | * group when they acquire rdtgroup_mutex |
257 | * @type: indicates type of this rdtgroup - either |
258 | * monitor only or ctrl_mon group |
259 | * @mon: mongroup related data |
260 | * @mode: mode of resource group |
261 | * @plr: pseudo-locked region |
262 | */ |
263 | struct rdtgroup { |
264 | struct kernfs_node *kn; |
265 | struct list_head rdtgroup_list; |
266 | u32 closid; |
267 | struct cpumask cpu_mask; |
268 | int flags; |
269 | atomic_t waitcount; |
270 | enum rdt_group_type type; |
271 | struct mongroup mon; |
272 | enum rdtgrp_mode mode; |
273 | struct pseudo_lock_region *plr; |
274 | }; |
275 | |
276 | /* rdtgroup.flags */ |
277 | #define RDT_DELETED 1 |
278 | |
279 | /* rftype.flags */ |
280 | #define RFTYPE_FLAGS_CPUS_LIST 1 |
281 | |
282 | /* |
283 | * Define the file type flags for base and info directories. |
284 | */ |
285 | #define RFTYPE_INFO BIT(0) |
286 | #define RFTYPE_BASE BIT(1) |
287 | #define RFTYPE_CTRL BIT(4) |
288 | #define RFTYPE_MON BIT(5) |
289 | #define RFTYPE_TOP BIT(6) |
290 | #define RFTYPE_RES_CACHE BIT(8) |
291 | #define RFTYPE_RES_MB BIT(9) |
292 | #define RFTYPE_DEBUG BIT(10) |
293 | #define RFTYPE_CTRL_INFO (RFTYPE_INFO | RFTYPE_CTRL) |
294 | #define RFTYPE_MON_INFO (RFTYPE_INFO | RFTYPE_MON) |
295 | #define RFTYPE_TOP_INFO (RFTYPE_INFO | RFTYPE_TOP) |
296 | #define RFTYPE_CTRL_BASE (RFTYPE_BASE | RFTYPE_CTRL) |
297 | #define RFTYPE_MON_BASE (RFTYPE_BASE | RFTYPE_MON) |
298 | |
299 | /* List of all resource groups */ |
300 | extern struct list_head rdt_all_groups; |
301 | |
302 | extern int max_name_width, max_data_width; |
303 | |
304 | int __init rdtgroup_init(void); |
305 | void __exit rdtgroup_exit(void); |
306 | |
307 | /** |
308 | * struct rftype - describe each file in the resctrl file system |
309 | * @name: File name |
310 | * @mode: Access mode |
311 | * @kf_ops: File operations |
312 | * @flags: File specific RFTYPE_FLAGS_* flags |
313 | * @fflags: File specific RFTYPE_* flags |
314 | * @seq_show: Show content of the file |
315 | * @write: Write to the file |
316 | */ |
317 | struct rftype { |
318 | char *name; |
319 | umode_t mode; |
320 | const struct kernfs_ops *kf_ops; |
321 | unsigned long flags; |
322 | unsigned long fflags; |
323 | |
324 | int (*seq_show)(struct kernfs_open_file *of, |
325 | struct seq_file *sf, void *v); |
326 | /* |
327 | * write() is the generic write callback which maps directly to |
328 | * kernfs write operation and overrides all other operations. |
329 | * Maximum write size is determined by ->max_write_len. |
330 | */ |
331 | ssize_t (*write)(struct kernfs_open_file *of, |
332 | char *buf, size_t nbytes, loff_t off); |
333 | }; |
334 | |
335 | /** |
336 | * struct mbm_state - status for each MBM counter in each domain |
337 | * @prev_bw_bytes: Previous bytes value read for bandwidth calculation |
338 | * @prev_bw: The most recent bandwidth in MBps |
339 | */ |
340 | struct mbm_state { |
341 | u64 prev_bw_bytes; |
342 | u32 prev_bw; |
343 | }; |
344 | |
345 | /** |
346 | * struct arch_mbm_state - values used to compute resctrl_arch_rmid_read()s |
347 | * return value. |
348 | * @chunks: Total data moved (multiply by rdt_group.mon_scale to get bytes) |
349 | * @prev_msr: Value of IA32_QM_CTR last time it was read for the RMID used to |
350 | * find this struct. |
351 | */ |
352 | struct arch_mbm_state { |
353 | u64 chunks; |
354 | u64 prev_msr; |
355 | }; |
356 | |
357 | /** |
358 | * struct rdt_hw_domain - Arch private attributes of a set of CPUs that share |
359 | * a resource |
360 | * @d_resctrl: Properties exposed to the resctrl file system |
361 | * @ctrl_val: array of cache or mem ctrl values (indexed by CLOSID) |
362 | * @arch_mbm_total: arch private state for MBM total bandwidth |
363 | * @arch_mbm_local: arch private state for MBM local bandwidth |
364 | * |
365 | * Members of this structure are accessed via helpers that provide abstraction. |
366 | */ |
367 | struct rdt_hw_domain { |
368 | struct rdt_domain d_resctrl; |
369 | u32 *ctrl_val; |
370 | struct arch_mbm_state *arch_mbm_total; |
371 | struct arch_mbm_state *arch_mbm_local; |
372 | }; |
373 | |
374 | static inline struct rdt_hw_domain *resctrl_to_arch_dom(struct rdt_domain *r) |
375 | { |
376 | return container_of(r, struct rdt_hw_domain, d_resctrl); |
377 | } |
378 | |
379 | /** |
380 | * struct msr_param - set a range of MSRs from a domain |
381 | * @res: The resource to use |
382 | * @low: Beginning index from base MSR |
383 | * @high: End index |
384 | */ |
385 | struct msr_param { |
386 | struct rdt_resource *res; |
387 | u32 low; |
388 | u32 high; |
389 | }; |
390 | |
391 | static inline bool is_llc_occupancy_enabled(void) |
392 | { |
393 | return (rdt_mon_features & (1 << QOS_L3_OCCUP_EVENT_ID)); |
394 | } |
395 | |
396 | static inline bool is_mbm_total_enabled(void) |
397 | { |
398 | return (rdt_mon_features & (1 << QOS_L3_MBM_TOTAL_EVENT_ID)); |
399 | } |
400 | |
401 | static inline bool is_mbm_local_enabled(void) |
402 | { |
403 | return (rdt_mon_features & (1 << QOS_L3_MBM_LOCAL_EVENT_ID)); |
404 | } |
405 | |
406 | static inline bool is_mbm_enabled(void) |
407 | { |
408 | return (is_mbm_total_enabled() || is_mbm_local_enabled()); |
409 | } |
410 | |
411 | static inline bool is_mbm_event(int e) |
412 | { |
413 | return (e >= QOS_L3_MBM_TOTAL_EVENT_ID && |
414 | e <= QOS_L3_MBM_LOCAL_EVENT_ID); |
415 | } |
416 | |
417 | struct rdt_parse_data { |
418 | struct rdtgroup *rdtgrp; |
419 | char *buf; |
420 | }; |
421 | |
422 | /** |
423 | * struct rdt_hw_resource - arch private attributes of a resctrl resource |
424 | * @r_resctrl: Attributes of the resource used directly by resctrl. |
425 | * @num_closid: Maximum number of closid this hardware can support, |
426 | * regardless of CDP. This is exposed via |
427 | * resctrl_arch_get_num_closid() to avoid confusion |
428 | * with struct resctrl_schema's property of the same name, |
429 | * which has been corrected for features like CDP. |
430 | * @msr_base: Base MSR address for CBMs |
431 | * @msr_update: Function pointer to update QOS MSRs |
432 | * @mon_scale: cqm counter * mon_scale = occupancy in bytes |
433 | * @mbm_width: Monitor width, to detect and correct for overflow. |
434 | * @mbm_cfg_mask: Bandwidth sources that can be tracked when Bandwidth |
435 | * Monitoring Event Configuration (BMEC) is supported. |
436 | * @cdp_enabled: CDP state of this resource |
437 | * |
438 | * Members of this structure are either private to the architecture |
439 | * e.g. mbm_width, or accessed via helpers that provide abstraction. e.g. |
440 | * msr_update and msr_base. |
441 | */ |
442 | struct rdt_hw_resource { |
443 | struct rdt_resource r_resctrl; |
444 | u32 num_closid; |
445 | unsigned int msr_base; |
446 | void (*msr_update) (struct rdt_domain *d, struct msr_param *m, |
447 | struct rdt_resource *r); |
448 | unsigned int mon_scale; |
449 | unsigned int mbm_width; |
450 | unsigned int mbm_cfg_mask; |
451 | bool cdp_enabled; |
452 | }; |
453 | |
454 | static inline struct rdt_hw_resource *resctrl_to_arch_res(struct rdt_resource *r) |
455 | { |
456 | return container_of(r, struct rdt_hw_resource, r_resctrl); |
457 | } |
458 | |
459 | int parse_cbm(struct rdt_parse_data *data, struct resctrl_schema *s, |
460 | struct rdt_domain *d); |
461 | int parse_bw(struct rdt_parse_data *data, struct resctrl_schema *s, |
462 | struct rdt_domain *d); |
463 | |
464 | extern struct mutex rdtgroup_mutex; |
465 | |
466 | extern struct rdt_hw_resource rdt_resources_all[]; |
467 | extern struct rdtgroup rdtgroup_default; |
468 | extern struct dentry *debugfs_resctrl; |
469 | |
470 | enum resctrl_res_level { |
471 | RDT_RESOURCE_L3, |
472 | RDT_RESOURCE_L2, |
473 | RDT_RESOURCE_MBA, |
474 | RDT_RESOURCE_SMBA, |
475 | |
476 | /* Must be the last */ |
477 | RDT_NUM_RESOURCES, |
478 | }; |
479 | |
480 | static inline struct rdt_resource *resctrl_inc(struct rdt_resource *res) |
481 | { |
482 | struct rdt_hw_resource *hw_res = resctrl_to_arch_res(r: res); |
483 | |
484 | hw_res++; |
485 | return &hw_res->r_resctrl; |
486 | } |
487 | |
488 | static inline bool resctrl_arch_get_cdp_enabled(enum resctrl_res_level l) |
489 | { |
490 | return rdt_resources_all[l].cdp_enabled; |
491 | } |
492 | |
493 | int resctrl_arch_set_cdp_enabled(enum resctrl_res_level l, bool enable); |
494 | |
495 | /* |
496 | * To return the common struct rdt_resource, which is contained in struct |
497 | * rdt_hw_resource, walk the resctrl member of struct rdt_hw_resource. |
498 | */ |
499 | #define for_each_rdt_resource(r) \ |
500 | for (r = &rdt_resources_all[0].r_resctrl; \ |
501 | r <= &rdt_resources_all[RDT_NUM_RESOURCES - 1].r_resctrl; \ |
502 | r = resctrl_inc(r)) |
503 | |
504 | #define for_each_capable_rdt_resource(r) \ |
505 | for_each_rdt_resource(r) \ |
506 | if (r->alloc_capable || r->mon_capable) |
507 | |
508 | #define for_each_alloc_capable_rdt_resource(r) \ |
509 | for_each_rdt_resource(r) \ |
510 | if (r->alloc_capable) |
511 | |
512 | #define for_each_mon_capable_rdt_resource(r) \ |
513 | for_each_rdt_resource(r) \ |
514 | if (r->mon_capable) |
515 | |
516 | /* CPUID.(EAX=10H, ECX=ResID=1).EAX */ |
517 | union cpuid_0x10_1_eax { |
518 | struct { |
519 | unsigned int cbm_len:5; |
520 | } split; |
521 | unsigned int full; |
522 | }; |
523 | |
524 | /* CPUID.(EAX=10H, ECX=ResID=3).EAX */ |
525 | union cpuid_0x10_3_eax { |
526 | struct { |
527 | unsigned int max_delay:12; |
528 | } split; |
529 | unsigned int full; |
530 | }; |
531 | |
532 | /* CPUID.(EAX=10H, ECX=ResID).ECX */ |
533 | union cpuid_0x10_x_ecx { |
534 | struct { |
535 | unsigned int reserved:3; |
536 | unsigned int noncont:1; |
537 | } split; |
538 | unsigned int full; |
539 | }; |
540 | |
541 | /* CPUID.(EAX=10H, ECX=ResID).EDX */ |
542 | union cpuid_0x10_x_edx { |
543 | struct { |
544 | unsigned int cos_max:16; |
545 | } split; |
546 | unsigned int full; |
547 | }; |
548 | |
549 | void rdt_last_cmd_clear(void); |
550 | void rdt_last_cmd_puts(const char *s); |
551 | __printf(1, 2) |
552 | void rdt_last_cmd_printf(const char *fmt, ...); |
553 | |
554 | void rdt_ctrl_update(void *arg); |
555 | struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn); |
556 | void rdtgroup_kn_unlock(struct kernfs_node *kn); |
557 | int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name); |
558 | int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name, |
559 | umode_t mask); |
560 | struct rdt_domain *rdt_find_domain(struct rdt_resource *r, int id, |
561 | struct list_head **pos); |
562 | ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of, |
563 | char *buf, size_t nbytes, loff_t off); |
564 | int rdtgroup_schemata_show(struct kernfs_open_file *of, |
565 | struct seq_file *s, void *v); |
566 | bool rdtgroup_cbm_overlaps(struct resctrl_schema *s, struct rdt_domain *d, |
567 | unsigned long cbm, int closid, bool exclusive); |
568 | unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, struct rdt_domain *d, |
569 | unsigned long cbm); |
570 | enum rdtgrp_mode rdtgroup_mode_by_closid(int closid); |
571 | int rdtgroup_tasks_assigned(struct rdtgroup *r); |
572 | int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp); |
573 | int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp); |
574 | bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_domain *d, unsigned long cbm); |
575 | bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_domain *d); |
576 | int rdt_pseudo_lock_init(void); |
577 | void rdt_pseudo_lock_release(void); |
578 | int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp); |
579 | void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp); |
580 | struct rdt_domain *get_domain_from_cpu(int cpu, struct rdt_resource *r); |
581 | int closids_supported(void); |
582 | void closid_free(int closid); |
583 | int alloc_rmid(u32 closid); |
584 | void free_rmid(u32 closid, u32 rmid); |
585 | int rdt_get_mon_l3_config(struct rdt_resource *r); |
586 | void __exit rdt_put_mon_l3_config(void); |
587 | bool __init rdt_cpu_has(int flag); |
588 | void mon_event_count(void *info); |
589 | int rdtgroup_mondata_show(struct seq_file *m, void *arg); |
590 | void mon_event_read(struct rmid_read *rr, struct rdt_resource *r, |
591 | struct rdt_domain *d, struct rdtgroup *rdtgrp, |
592 | int evtid, int first); |
593 | void mbm_setup_overflow_handler(struct rdt_domain *dom, |
594 | unsigned long delay_ms, |
595 | int exclude_cpu); |
596 | void mbm_handle_overflow(struct work_struct *work); |
597 | void __init intel_rdt_mbm_apply_quirk(void); |
598 | bool is_mba_sc(struct rdt_resource *r); |
599 | void cqm_setup_limbo_handler(struct rdt_domain *dom, unsigned long delay_ms, |
600 | int exclude_cpu); |
601 | void cqm_handle_limbo(struct work_struct *work); |
602 | bool has_busy_rmid(struct rdt_domain *d); |
603 | void __check_limbo(struct rdt_domain *d, bool force_free); |
604 | void rdt_domain_reconfigure_cdp(struct rdt_resource *r); |
605 | void __init thread_throttle_mode_init(void); |
606 | void __init mbm_config_rftype_init(const char *config); |
607 | void rdt_staged_configs_clear(void); |
608 | bool closid_allocated(unsigned int closid); |
609 | int resctrl_find_cleanest_closid(void); |
610 | |
611 | #endif /* _ASM_X86_RESCTRL_INTERNAL_H */ |
612 | |