x86/resctrl: Move the filesystem portions of resctrl to live in '/fs/' (13e249bf) · Commits · EulixOS / Software / Kernel

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

+0 −15

Original line number	Diff line number	Diff line
		@@ -164,21 +164,6 @@ static inline void cache_alloc_hsw_probe(void)
		rdt_alloc_capable = true;
		}

		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;
		}

		/*
		* rdt_get_mb_table() - get a mapping of bandwidth(b/w) percentage values
		* exposed to user interface and the h/w understandable delay values.

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

+0 −506

Original line number	Diff line number	Diff line
		@@ -23,261 +23,6 @@

		#include "internal.h"

		struct rdt_parse_data {
		struct rdtgroup *rdtgrp;
		char *buf;
		};

		typedef int (ctrlval_parser_t)(struct rdt_parse_data *data,
		struct resctrl_schema *s,
		struct rdt_domain *d);

		/*
		* Check whether MBA bandwidth percentage value is correct. The value is
		* checked against the minimum and max bandwidth values specified by the
		* hardware. The allocated bandwidth percentage is rounded to the next
		* control step available on the hardware.
		*/
		static bool bw_validate(char buf, unsigned long data, struct rdt_resource *r)
		{
		unsigned long bw;
		int ret;

		/*
		* Only linear delay values is supported for current Intel SKUs.
		*/
		if (!r->membw.delay_linear && r->membw.arch_needs_linear) {
		rdt_last_cmd_puts("No support for non-linear MB domains\n");
		return false;
		}

		ret = kstrtoul(buf, 10, &bw);
		if (ret) {
		rdt_last_cmd_printf("Non-decimal digit in MB value %s\n", buf);
		return false;
		}

		if ((bw < r->membw.min_bw \|\| bw > r->default_ctrl) &&
		!is_mba_sc(r)) {
		rdt_last_cmd_printf("MB value %ld out of range [%d,%d]\n", bw,
		r->membw.min_bw, r->default_ctrl);
		return false;
		}

		*data = roundup(bw, (unsigned long)r->membw.bw_gran);
		return true;
		}

		static int parse_bw(struct rdt_parse_data data, struct resctrl_schema s,
		struct rdt_domain *d)
		{
		struct resctrl_staged_config *cfg;
		u32 closid = data->rdtgrp->closid;
		struct rdt_resource *r = s->res;
		unsigned long bw_val;

		cfg = &d->staged_config[s->conf_type];
		if (cfg->have_new_ctrl) {
		rdt_last_cmd_printf("Duplicate domain %d\n", d->id);
		return -EINVAL;
		}

		if (!bw_validate(data->buf, &bw_val, r))
		return -EINVAL;

		if (is_mba_sc(r)) {
		d->mbps_val[closid] = bw_val;
		return 0;
		}

		cfg->new_ctrl = bw_val;
		cfg->have_new_ctrl = true;

		return 0;
		}

		/*
		* Check whether a cache bit mask is valid.
		* On Intel CPUs, non-contiguous 1s value support is indicated by CPUID:
		* - CPUID.0x10.1:ECX[3]: L3 non-contiguous 1s value supported if 1
		* - CPUID.0x10.2:ECX[3]: L2 non-contiguous 1s value supported if 1
		*
		* Haswell does not support a non-contiguous 1s value and additionally
		* requires at least two bits set.
		* AMD allows non-contiguous bitmasks.
		*/
		static bool cbm_validate(char buf, u32 data, struct rdt_resource *r)
		{
		unsigned long first_bit, zero_bit, val;
		unsigned int cbm_len = r->cache.cbm_len;
		int ret;

		ret = kstrtoul(buf, 16, &val);
		if (ret) {
		rdt_last_cmd_printf("Non-hex character in the mask %s\n", buf);
		return false;
		}

		if ((r->cache.min_cbm_bits > 0 && val == 0) \|\| val > r->default_ctrl) {
		rdt_last_cmd_puts("Mask out of range\n");
		return false;
		}

		first_bit = find_first_bit(&val, cbm_len);
		zero_bit = find_next_zero_bit(&val, cbm_len, first_bit);

		/* Are non-contiguous bitmasks allowed? */
		if (!r->cache.arch_has_sparse_bitmasks &&
		(find_next_bit(&val, cbm_len, zero_bit) < cbm_len)) {
		rdt_last_cmd_printf("The mask %lx has non-consecutive 1-bits\n", val);
		return false;
		}

		if ((zero_bit - first_bit) < r->cache.min_cbm_bits) {
		rdt_last_cmd_printf("Need at least %d bits in the mask\n",
		r->cache.min_cbm_bits);
		return false;
		}

		*data = val;
		return true;
		}

		/*
		* Read one cache bit mask (hex). Check that it is valid for the current
		* resource type.
		*/
		static int parse_cbm(struct rdt_parse_data data, struct resctrl_schema s,
		struct rdt_domain *d)
		{
		struct rdtgroup *rdtgrp = data->rdtgrp;
		struct resctrl_staged_config *cfg;
		struct rdt_resource *r = s->res;
		u32 cbm_val;

		cfg = &d->staged_config[s->conf_type];
		if (cfg->have_new_ctrl) {
		rdt_last_cmd_printf("Duplicate domain %d\n", d->id);
		return -EINVAL;
		}

		/*
		* Cannot set up more than one pseudo-locked region in a cache
		* hierarchy.
		*/
		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP &&
		rdtgroup_pseudo_locked_in_hierarchy(d)) {
		rdt_last_cmd_puts("Pseudo-locked region in hierarchy\n");
		return -EINVAL;
		}

		if (!cbm_validate(data->buf, &cbm_val, r))
		return -EINVAL;

		if (IS_ENABLED(CONFIG_RESCTRL_FS_PSEUDO_LOCK) &&
		(rdtgrp->mode == RDT_MODE_EXCLUSIVE \|\|
		rdtgrp->mode == RDT_MODE_SHAREABLE) &&
		rdtgroup_cbm_overlaps_pseudo_locked(d, cbm_val)) {
		rdt_last_cmd_puts("CBM overlaps with pseudo-locked region\n");
		return -EINVAL;
		}

		/*
		* The CBM may not overlap with the CBM of another closid if
		* either is exclusive.
		*/
		if (rdtgroup_cbm_overlaps(s, d, cbm_val, rdtgrp->closid, true)) {
		rdt_last_cmd_puts("Overlaps with exclusive group\n");
		return -EINVAL;
		}

		if (rdtgroup_cbm_overlaps(s, d, cbm_val, rdtgrp->closid, false)) {
		if (rdtgrp->mode == RDT_MODE_EXCLUSIVE \|\|
		rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
		rdt_last_cmd_puts("Overlaps with other group\n");
		return -EINVAL;
		}
		}

		cfg->new_ctrl = cbm_val;
		cfg->have_new_ctrl = true;

		return 0;
		}

		static ctrlval_parser_t get_parser(struct rdt_resource res)
		{
		if (res->fflags & RFTYPE_RES_CACHE)
		return &parse_cbm;
		else
		return &parse_bw;
		}

		/*
		* For each domain in this resource we expect to find a series of:
		* id=mask
		* separated by ";". The "id" is in decimal, and must match one of
		* the "id"s for this resource.
		*/
		static int parse_line(char line, struct resctrl_schema s,
		struct rdtgroup *rdtgrp)
		{
		ctrlval_parser_t *parse_ctrlval = get_parser(s->res);
		enum resctrl_conf_type t = s->conf_type;
		struct resctrl_staged_config *cfg;
		struct rdt_resource *r = s->res;
		struct rdt_parse_data data;
		char dom = NULL, id;
		struct rdt_domain *d;
		unsigned long dom_id;

		/* Walking r->domains, ensure it can't race with cpuhp */
		lockdep_assert_cpus_held();

		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP &&
		(r->rid == RDT_RESOURCE_MBA \|\| r->rid == RDT_RESOURCE_SMBA)) {
		rdt_last_cmd_puts("Cannot pseudo-lock MBA resource\n");
		return -EINVAL;
		}

		next:
		if (!line \|\| line[0] == '\0')
		return 0;
		dom = strsep(&line, ";");
		id = strsep(&dom, "=");
		if (!dom \|\| kstrtoul(id, 10, &dom_id)) {
		rdt_last_cmd_puts("Missing '=' or non-numeric domain\n");
		return -EINVAL;
		}
		dom = strim(dom);
		list_for_each_entry(d, &r->domains, list) {
		if (d->id == dom_id) {
		data.buf = dom;
		data.rdtgrp = rdtgrp;
		if (parse_ctrlval(&data, s, d))
		return -EINVAL;
		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
		cfg = &d->staged_config[t];
		/*
		* In pseudo-locking setup mode and just
		* parsed a valid CBM that should be
		* pseudo-locked. Only one locked region per
		* resource group and domain so just do
		* the required initialization for single
		* region and return.
		*/
		rdtgrp->plr->s = s;
		rdtgrp->plr->d = d;
		rdtgrp->plr->cbm = cfg->new_ctrl;
		d->plr = rdtgrp->plr;
		return 0;
		}
		goto next;
		}
		}
		return -EINVAL;
		}

		static bool apply_config(struct rdt_hw_domain *hw_dom,
		struct resctrl_staged_config *cfg, u32 idx,
		cpumask_var_t cpu_mask)
		@@ -366,100 +111,6 @@ int resctrl_arch_update_domains(struct rdt_resource *r, u32 closid)
		return 0;
		}

		static int rdtgroup_parse_resource(char resname, char tok,
		struct rdtgroup *rdtgrp)
		{
		struct resctrl_schema *s;

		list_for_each_entry(s, &resctrl_schema_all, list) {
		if (!strcmp(resname, s->name) && rdtgrp->closid < s->num_closid)
		return parse_line(tok, s, rdtgrp);
		}
		rdt_last_cmd_printf("Unknown or unsupported resource name '%s'\n", resname);
		return -EINVAL;
		}

		ssize_t rdtgroup_schemata_write(struct kernfs_open_file *of,
		char *buf, size_t nbytes, loff_t off)
		{
		struct resctrl_schema *s;
		struct rdtgroup *rdtgrp;
		struct rdt_resource *r;
		char tok, resname;
		int ret = 0;

		/* Valid input requires a trailing newline */
		if (nbytes == 0 \|\| buf[nbytes - 1] != '\n')
		return -EINVAL;
		buf[nbytes - 1] = '\0';

		rdtgrp = rdtgroup_kn_lock_live(of->kn);
		if (!rdtgrp) {
		rdtgroup_kn_unlock(of->kn);
		return -ENOENT;
		}
		rdt_last_cmd_clear();

		/*
		* No changes to pseudo-locked region allowed. It has to be removed
		* and re-created instead.
		*/
		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
		ret = -EINVAL;
		rdt_last_cmd_puts("Resource group is pseudo-locked\n");
		goto out;
		}

		rdt_staged_configs_clear();

		while ((tok = strsep(&buf, "\n")) != NULL) {
		resname = strim(strsep(&tok, ":"));
		if (!tok) {
		rdt_last_cmd_puts("Missing ':'\n");
		ret = -EINVAL;
		goto out;
		}
		if (tok[0] == '\0') {
		rdt_last_cmd_printf("Missing '%s' value\n", resname);
		ret = -EINVAL;
		goto out;
		}
		ret = rdtgroup_parse_resource(resname, tok, rdtgrp);
		if (ret)
		goto out;
		}

		list_for_each_entry(s, &resctrl_schema_all, list) {
		r = s->res;

		/*
		* Writes to mba_sc resources update the software controller,
		* not the control MSR.
		*/
		if (is_mba_sc(r))
		continue;

		ret = resctrl_arch_update_domains(r, rdtgrp->closid);
		if (ret)
		goto out;
		}

		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
		/*
		* If pseudo-locking fails we keep the resource group in
		* mode RDT_MODE_PSEUDO_LOCKSETUP with its class of service
		* active and updated for just the domain the pseudo-locked
		* region was requested for.
		*/
		ret = rdtgroup_pseudo_lock_create(rdtgrp);
		}

		out:
		rdt_staged_configs_clear();
		rdtgroup_kn_unlock(of->kn);
		return ret ?: nbytes;
		}

		u32 resctrl_arch_get_config(struct rdt_resource r, struct rdt_domain d,
		u32 closid, enum resctrl_conf_type type)
		{
		@@ -468,160 +119,3 @@ u32 resctrl_arch_get_config(struct rdt_resource r, struct rdt_domain d,

		return hw_dom->ctrl_val[idx];
		}

		static void show_doms(struct seq_file s, struct resctrl_schema schema, int closid)
		{
		struct rdt_resource *r = schema->res;
		struct rdt_domain *dom;
		bool sep = false;
		u32 ctrl_val;

		/* Walking r->domains, ensure it can't race with cpuhp */
		lockdep_assert_cpus_held();

		seq_printf(s, "%*s:", max_name_width, schema->name);
		list_for_each_entry(dom, &r->domains, list) {
		if (sep)
		seq_puts(s, ";");

		if (is_mba_sc(r))
		ctrl_val = dom->mbps_val[closid];
		else
		ctrl_val = resctrl_arch_get_config(r, dom, closid,
		schema->conf_type);

		seq_printf(s, r->format_str, dom->id, max_data_width,
		ctrl_val);
		sep = true;
		}
		seq_puts(s, "\n");
		}

		int rdtgroup_schemata_show(struct kernfs_open_file *of,
		struct seq_file s, void v)
		{
		struct resctrl_schema *schema;
		struct rdtgroup *rdtgrp;
		int ret = 0;
		u32 closid;

		rdtgrp = rdtgroup_kn_lock_live(of->kn);
		if (rdtgrp) {
		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
		list_for_each_entry(schema, &resctrl_schema_all, list) {
		seq_printf(s, "%s:uninitialized\n", schema->name);
		}
		} else if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
		if (!rdtgrp->plr->d) {
		rdt_last_cmd_clear();
		rdt_last_cmd_puts("Cache domain offline\n");
		ret = -ENODEV;
		} else {
		seq_printf(s, "%s:%d=%x\n",
		rdtgrp->plr->s->res->name,
		rdtgrp->plr->d->id,
		rdtgrp->plr->cbm);
		}
		} else {
		closid = rdtgrp->closid;
		list_for_each_entry(schema, &resctrl_schema_all, list) {
		if (closid < schema->num_closid)
		show_doms(s, schema, closid);
		}
		}
		} else {
		ret = -ENOENT;
		}
		rdtgroup_kn_unlock(of->kn);
		return ret;
		}

		static int smp_mon_event_count(void *arg)
		{
		mon_event_count(arg);

		return 0;
		}

		void mon_event_read(struct rmid_read rr, struct rdt_resource r,
		struct rdt_domain d, struct rdtgroup rdtgrp,
		int evtid, int first)
		{
		int cpu;

		/* When picking a CPU from cpu_mask, ensure it can't race with cpuhp */
		lockdep_assert_cpus_held();

		/*
		* Setup the parameters to pass to mon_event_count() to read the data.
		*/
		rr->rgrp = rdtgrp;
		rr->evtid = evtid;
		rr->r = r;
		rr->d = d;
		rr->val = 0;
		rr->first = first;
		rr->arch_mon_ctx = resctrl_arch_mon_ctx_alloc(r, evtid);
		if (IS_ERR(rr->arch_mon_ctx)) {
		rr->err = -EINVAL;
		return;
		}

		cpu = cpumask_any_housekeeping(&d->cpu_mask, RESCTRL_PICK_ANY_CPU);

		/*
		* cpumask_any_housekeeping() prefers housekeeping CPUs, but
		* are all the CPUs nohz_full? If yes, pick a CPU to IPI.
		* MPAM's resctrl_arch_rmid_read() is unable to read the
		* counters on some platforms if its called in irq context.
		*/
		if (tick_nohz_full_cpu(cpu))
		smp_call_function_any(&d->cpu_mask, mon_event_count, rr, 1);
		else
		smp_call_on_cpu(cpu, smp_mon_event_count, rr, false);

		resctrl_arch_mon_ctx_free(r, evtid, rr->arch_mon_ctx);
		}

		int rdtgroup_mondata_show(struct seq_file m, void arg)
		{
		struct kernfs_open_file *of = m->private;
		u32 resid, evtid, domid;
		struct rdtgroup *rdtgrp;
		struct rdt_resource *r;
		union mon_data_bits md;
		struct rdt_domain *d;
		struct rmid_read rr;
		int ret = 0;

		rdtgrp = rdtgroup_kn_lock_live(of->kn);
		if (!rdtgrp) {
		ret = -ENOENT;
		goto out;
		}

		md.priv = of->kn->priv;
		resid = md.u.rid;
		domid = md.u.domid;
		evtid = md.u.evtid;

		r = resctrl_arch_get_resource(resid);
		d = resctrl_arch_find_domain(r, domid);
		if (IS_ERR_OR_NULL(d)) {
		ret = -ENOENT;
		goto out;
		}

		mon_event_read(&rr, r, d, rdtgrp, evtid, false);

		if (rr.err == -EIO)
		seq_puts(m, "Error\n");
		else if (rr.err == -EINVAL)
		seq_puts(m, "Unavailable\n");
		else
		seq_printf(m, "%llu\n", rr.val);

		out:
		rdtgroup_kn_unlock(of->kn);
		return ret;
		}

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

+0 −282

Original line number	Diff line number	Diff line
		@@ -27,231 +27,6 @@
		*/
		#define MBM_CNTR_WIDTH_OFFSET_MAX (62 - MBM_CNTR_WIDTH_BASE)

		/**
		* 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;
		};

		/**
		* struct arch_mbm_state - values used to compute resctrl_arch_rmid_read()s
		* return value.
		@@ -343,11 +118,7 @@ static inline struct rdt_hw_resource resctrl_to_arch_res(struct rdt_resource r
		return container_of(r, struct rdt_hw_resource, r_resctrl);
		}

		extern struct mutex rdtgroup_mutex;

		extern struct rdt_hw_resource rdt_resources_all[];
		extern struct rdtgroup rdtgroup_default;
		extern struct dentry *debugfs_resctrl;

		static inline struct rdt_resource resctrl_inc(struct rdt_resource res)
		{
		@@ -411,62 +182,9 @@ union cpuid_0x10_x_edx {
		unsigned int full;
		};

		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, ...);

		void rdt_ctrl_update(void *arg);
		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);
		void closid_free(int closid);
		int alloc_rmid(u32 closid);
		void free_rmid(u32 closid, u32 rmid);
		int rdt_get_mon_l3_config(struct rdt_resource *r);
		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 __init intel_rdt_mbm_apply_quirk(void);
		bool is_mba_sc(struct rdt_resource *r);
		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 rdt_domain_reconfigure_cdp(struct rdt_resource *r);
		void mbm_config_rftype_init(const char *config);
		void rdt_staged_configs_clear(void);
		bool closid_allocated(unsigned int closid);
		int resctrl_find_cleanest_closid(void);

		#endif /* _ASM_X86_RESCTRL_INTERNAL_H */

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

+0 −837

File changed.

Preview size limit exceeded, changes collapsed.

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

+0 −1105

File changed.

Preview size limit exceeded, changes collapsed.