314 lines
9.5 KiB
C
314 lines
9.5 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef _FS_RESCTRL_INTERNAL_H
|
|
#define _FS_RESCTRL_INTERNAL_H
|
|
|
|
#include <linux/resctrl.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/kernfs.h>
|
|
#include <linux/fs_context.h>
|
|
#include <linux/jump_label.h>
|
|
#include <linux/tick.h>
|
|
|
|
#include <asm/resctrl.h>
|
|
|
|
/**
|
|
* cpumask_any_housekeeping() - Choose any CPU in @mask, preferring those that
|
|
* aren't marked nohz_full
|
|
* @mask: The mask to pick a CPU from.
|
|
* @exclude_cpu:The CPU to avoid picking.
|
|
*
|
|
* Returns a CPU from @mask, but not @exclude_cpu. If there are housekeeping
|
|
* CPUs that don't use nohz_full, these are preferred. Pass
|
|
* RESCTRL_PICK_ANY_CPU to avoid excluding any CPUs.
|
|
*
|
|
* When a CPU is excluded, returns >= nr_cpu_ids if no CPUs are available.
|
|
*/
|
|
static inline unsigned int
|
|
cpumask_any_housekeeping(const struct cpumask *mask, int exclude_cpu)
|
|
{
|
|
unsigned int cpu, hk_cpu;
|
|
|
|
if (exclude_cpu == RESCTRL_PICK_ANY_CPU)
|
|
cpu = cpumask_any(mask);
|
|
else
|
|
cpu = cpumask_any_but(mask, exclude_cpu);
|
|
|
|
if (!IS_ENABLED(CONFIG_NO_HZ_FULL))
|
|
return cpu;
|
|
|
|
/* If the CPU picked isn't marked nohz_full nothing more needs doing. */
|
|
if (cpu < nr_cpu_ids && !tick_nohz_full_cpu(cpu))
|
|
return cpu;
|
|
|
|
/* Try to find a CPU that isn't nohz_full to use in preference */
|
|
hk_cpu = cpumask_nth_andnot(0, mask, tick_nohz_full_mask);
|
|
if (hk_cpu == exclude_cpu)
|
|
hk_cpu = cpumask_nth_andnot(1, mask, tick_nohz_full_mask);
|
|
|
|
if (hk_cpu < nr_cpu_ids)
|
|
cpu = hk_cpu;
|
|
|
|
return cpu;
|
|
}
|
|
|
|
struct rdt_fs_context {
|
|
struct kernfs_fs_context kfc;
|
|
bool enable_cdpl2;
|
|
bool enable_cdpl3;
|
|
bool enable_mba_mbps;
|
|
bool enable_debug;
|
|
};
|
|
|
|
static inline struct rdt_fs_context *rdt_fc2context(struct fs_context *fc)
|
|
{
|
|
struct kernfs_fs_context *kfc = fc->fs_private;
|
|
|
|
return container_of(kfc, struct rdt_fs_context, kfc);
|
|
}
|
|
|
|
/**
|
|
* struct mon_evt - Entry in the event list of a resource
|
|
* @evtid: event id
|
|
* @name: name of the event
|
|
* @configurable: true if the event is configurable
|
|
* @list: entry in &rdt_resource->evt_list
|
|
*/
|
|
struct mon_evt {
|
|
enum resctrl_event_id evtid;
|
|
char *name;
|
|
bool configurable;
|
|
struct list_head list;
|
|
};
|
|
|
|
/**
|
|
* union mon_data_bits - Monitoring details for each event file
|
|
* @priv: Used to store monitoring event data in @u
|
|
* as kernfs private data
|
|
* @rid: Resource id associated with the event file
|
|
* @evtid: Event id associated with the event file
|
|
* @domid: The domain to which the event file belongs
|
|
* @u: Name of the bit fields struct
|
|
*/
|
|
union mon_data_bits {
|
|
void *priv;
|
|
struct {
|
|
unsigned int rid : 10;
|
|
enum resctrl_event_id evtid : 8;
|
|
unsigned int domid : 14;
|
|
} u;
|
|
};
|
|
|
|
struct rmid_read {
|
|
struct rdtgroup *rgrp;
|
|
struct rdt_resource *r;
|
|
struct rdt_domain *d;
|
|
enum resctrl_event_id evtid;
|
|
bool first;
|
|
int err;
|
|
u64 val;
|
|
void *arch_mon_ctx;
|
|
};
|
|
|
|
extern struct list_head resctrl_schema_all;
|
|
extern bool resctrl_mounted;
|
|
|
|
enum rdt_group_type {
|
|
RDTCTRL_GROUP = 0,
|
|
RDTMON_GROUP,
|
|
RDT_NUM_GROUP,
|
|
};
|
|
|
|
/**
|
|
* enum rdtgrp_mode - Mode of a RDT resource group
|
|
* @RDT_MODE_SHAREABLE: This resource group allows sharing of its allocations
|
|
* @RDT_MODE_EXCLUSIVE: No sharing of this resource group's allocations allowed
|
|
* @RDT_MODE_PSEUDO_LOCKSETUP: Resource group will be used for Pseudo-Locking
|
|
* @RDT_MODE_PSEUDO_LOCKED: No sharing of this resource group's allocations
|
|
* allowed AND the allocations are Cache Pseudo-Locked
|
|
* @RDT_NUM_MODES: Total number of modes
|
|
*
|
|
* The mode of a resource group enables control over the allowed overlap
|
|
* between allocations associated with different resource groups (classes
|
|
* of service). User is able to modify the mode of a resource group by
|
|
* writing to the "mode" resctrl file associated with the resource group.
|
|
*
|
|
* The "shareable", "exclusive", and "pseudo-locksetup" modes are set by
|
|
* writing the appropriate text to the "mode" file. A resource group enters
|
|
* "pseudo-locked" mode after the schemata is written while the resource
|
|
* group is in "pseudo-locksetup" mode.
|
|
*/
|
|
enum rdtgrp_mode {
|
|
RDT_MODE_SHAREABLE = 0,
|
|
RDT_MODE_EXCLUSIVE,
|
|
RDT_MODE_PSEUDO_LOCKSETUP,
|
|
RDT_MODE_PSEUDO_LOCKED,
|
|
|
|
/* Must be last */
|
|
RDT_NUM_MODES,
|
|
};
|
|
|
|
/**
|
|
* struct mongroup - store mon group's data in resctrl fs.
|
|
* @mon_data_kn: kernfs node for the mon_data directory
|
|
* @parent: parent rdtgrp
|
|
* @crdtgrp_list: child rdtgroup node list
|
|
* @rmid: rmid for this rdtgroup
|
|
*/
|
|
struct mongroup {
|
|
struct kernfs_node *mon_data_kn;
|
|
struct rdtgroup *parent;
|
|
struct list_head crdtgrp_list;
|
|
u32 rmid;
|
|
};
|
|
|
|
/**
|
|
* struct rdtgroup - store rdtgroup's data in resctrl file system.
|
|
* @kn: kernfs node
|
|
* @rdtgroup_list: linked list for all rdtgroups
|
|
* @closid: closid for this rdtgroup
|
|
* @cpu_mask: CPUs assigned to this rdtgroup
|
|
* @flags: status bits
|
|
* @waitcount: how many cpus expect to find this
|
|
* group when they acquire rdtgroup_mutex
|
|
* @type: indicates type of this rdtgroup - either
|
|
* monitor only or ctrl_mon group
|
|
* @mon: mongroup related data
|
|
* @mode: mode of resource group
|
|
* @plr: pseudo-locked region
|
|
*/
|
|
struct rdtgroup {
|
|
struct kernfs_node *kn;
|
|
struct list_head rdtgroup_list;
|
|
u32 closid;
|
|
struct cpumask cpu_mask;
|
|
int flags;
|
|
atomic_t waitcount;
|
|
enum rdt_group_type type;
|
|
struct mongroup mon;
|
|
enum rdtgrp_mode mode;
|
|
struct pseudo_lock_region *plr;
|
|
};
|
|
|
|
/* List of all resource groups */
|
|
extern struct list_head rdt_all_groups;
|
|
|
|
extern int max_name_width, max_data_width;
|
|
|
|
/**
|
|
* struct rftype - describe each file in the resctrl file system
|
|
* @name: File name
|
|
* @mode: Access mode
|
|
* @kf_ops: File operations
|
|
* @flags: File specific RFTYPE_FLAGS_* flags
|
|
* @fflags: File specific RFTYPE_* flags
|
|
* @seq_show: Show content of the file
|
|
* @write: Write to the file
|
|
*/
|
|
struct rftype {
|
|
char *name;
|
|
umode_t mode;
|
|
const struct kernfs_ops *kf_ops;
|
|
unsigned long flags;
|
|
unsigned long fflags;
|
|
|
|
int (*seq_show)(struct kernfs_open_file *of,
|
|
struct seq_file *sf, void *v);
|
|
/*
|
|
* write() is the generic write callback which maps directly to
|
|
* kernfs write operation and overrides all other operations.
|
|
* Maximum write size is determined by ->max_write_len.
|
|
*/
|
|
ssize_t (*write)(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes, loff_t off);
|
|
};
|
|
|
|
/**
|
|
* struct mbm_state - status for each MBM counter in each domain
|
|
* @prev_bw_bytes: Previous bytes value read for bandwidth calculation
|
|
* @prev_bw: The most recent bandwidth in MBps
|
|
* @delta_bw: Difference between the current and previous bandwidth
|
|
* @delta_comp: Indicates whether to compute the delta_bw
|
|
*/
|
|
struct mbm_state {
|
|
u64 prev_bw_bytes;
|
|
u32 prev_bw;
|
|
u32 delta_bw;
|
|
bool delta_comp;
|
|
};
|
|
|
|
static inline bool is_mba_sc(struct rdt_resource *r)
|
|
{
|
|
if (!r)
|
|
r = resctrl_arch_get_resource(RDT_RESOURCE_MBA);
|
|
|
|
/*
|
|
* The software controller support is only applicable to MBA resource.
|
|
* Make sure to check for resource type.
|
|
*/
|
|
if (r->rid != RDT_RESOURCE_MBA)
|
|
return false;
|
|
|
|
return r->membw.mba_sc;
|
|
}
|
|
|
|
extern struct mutex rdtgroup_mutex;
|
|
extern struct rdtgroup rdtgroup_default;
|
|
extern struct dentry *debugfs_resctrl;
|
|
|
|
void rdt_last_cmd_clear(void);
|
|
void rdt_last_cmd_puts(const char *s);
|
|
__printf(1, 2)
|
|
void rdt_last_cmd_printf(const char *fmt, ...);
|
|
|
|
struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn);
|
|
void rdtgroup_kn_unlock(struct kernfs_node *kn);
|
|
int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name);
|
|
int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name,
|
|
umode_t mask);
|
|
ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes, loff_t off);
|
|
int rdtgroup_schemata_show(struct kernfs_open_file *of,
|
|
struct seq_file *s, void *v);
|
|
bool rdtgroup_cbm_overlaps(struct resctrl_schema *s, struct rdt_domain *d,
|
|
unsigned long cbm, int closid, bool exclusive);
|
|
unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r, struct rdt_domain *d,
|
|
unsigned long cbm);
|
|
enum rdtgrp_mode rdtgroup_mode_by_closid(int closid);
|
|
int rdtgroup_tasks_assigned(struct rdtgroup *r);
|
|
int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp);
|
|
int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp);
|
|
bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_domain *d, unsigned long cbm);
|
|
bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_domain *d);
|
|
int rdt_pseudo_lock_init(void);
|
|
void rdt_pseudo_lock_release(void);
|
|
int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp);
|
|
void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp);
|
|
int closids_supported(void);
|
|
bool closid_allocated(unsigned int closid);
|
|
bool resctrl_closid_is_dirty(u32 closid);
|
|
void closid_free(int closid);
|
|
int alloc_rmid(u32 closid);
|
|
void free_rmid(u32 closid, u32 rmid);
|
|
void resctrl_mon_resource_exit(void);
|
|
void mon_event_count(void *info);
|
|
int rdtgroup_mondata_show(struct seq_file *m, void *arg);
|
|
void mon_event_read(struct rmid_read *rr, struct rdt_resource *r,
|
|
struct rdt_domain *d, struct rdtgroup *rdtgrp,
|
|
int evtid, int first);
|
|
int resctrl_mon_resource_init(void);
|
|
void mbm_setup_overflow_handler(struct rdt_domain *dom,
|
|
unsigned long delay_ms,
|
|
int exclude_cpu);
|
|
void mbm_handle_overflow(struct work_struct *work);
|
|
void setup_default_ctrlval(struct rdt_resource *r, u32 *dc);
|
|
void cqm_setup_limbo_handler(struct rdt_domain *dom, unsigned long delay_ms,
|
|
int exclude_cpu);
|
|
void cqm_handle_limbo(struct work_struct *work);
|
|
bool has_busy_rmid(struct rdt_domain *d);
|
|
void __check_limbo(struct rdt_domain *d, bool force_free);
|
|
void mbm_config_rftype_init(const char *config);
|
|
void rdt_staged_configs_clear(void);
|
|
int resctrl_find_cleanest_closid(void);
|
|
|
|
#endif /* _FS_RESCTRL_INTERNAL_H */
|