[thirdparty/kernel/stable.git] / block / blk-cgroup-rwstat.c

/* SPDX-License-Identifier: GPL-2.0
 *
 * Legacy blkg rwstat helpers enabled by CONFIG_BLK_CGROUP_RWSTAT.
 * Do not use in new code.
 */
#include "blk-cgroup-rwstat.h"

int blkg_rwstat_init(struct blkg_rwstat *rwstat, gfp_t gfp)
{
	int i, ret;

	ret = percpu_counter_init_many(rwstat->cpu_cnt, 0, gfp, BLKG_RWSTAT_NR);
	if (ret)
		return ret;

	for (i = 0; i < BLKG_RWSTAT_NR; i++)
		atomic64_set(&rwstat->aux_cnt[i], 0);
	return 0;
}
EXPORT_SYMBOL_GPL(blkg_rwstat_init);

void blkg_rwstat_exit(struct blkg_rwstat *rwstat)
{
	percpu_counter_destroy_many(rwstat->cpu_cnt, BLKG_RWSTAT_NR);
}
EXPORT_SYMBOL_GPL(blkg_rwstat_exit);

/**
 * __blkg_prfill_rwstat - prfill helper for a blkg_rwstat
 * @sf: seq_file to print to
 * @pd: policy private data of interest
 * @rwstat: rwstat to print
 *
 * Print @rwstat to @sf for the device assocaited with @pd.
 */
u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
			 const struct blkg_rwstat_sample *rwstat)
{
	static const char *rwstr[] = {
		[BLKG_RWSTAT_READ]	= "Read",
		[BLKG_RWSTAT_WRITE]	= "Write",
		[BLKG_RWSTAT_SYNC]	= "Sync",
		[BLKG_RWSTAT_ASYNC]	= "Async",
		[BLKG_RWSTAT_DISCARD]	= "Discard",
	};
	const char *dname = blkg_dev_name(pd->blkg);
	u64 v;
	int i;

	if (!dname)
		return 0;

	for (i = 0; i < BLKG_RWSTAT_NR; i++)
		seq_printf(sf, "%s %s %llu\n", dname, rwstr[i],
			   rwstat->cnt[i]);

	v = rwstat->cnt[BLKG_RWSTAT_READ] +
		rwstat->cnt[BLKG_RWSTAT_WRITE] +
		rwstat->cnt[BLKG_RWSTAT_DISCARD];
	seq_printf(sf, "%s Total %llu\n", dname, v);
	return v;
}
EXPORT_SYMBOL_GPL(__blkg_prfill_rwstat);

/**
 * blkg_prfill_rwstat - prfill callback for blkg_rwstat
 * @sf: seq_file to print to
 * @pd: policy private data of interest
 * @off: offset to the blkg_rwstat in @pd
 *
 * prfill callback for printing a blkg_rwstat.
 */
u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
		       int off)
{
	struct blkg_rwstat_sample rwstat = { };

	blkg_rwstat_read((void *)pd + off, &rwstat);
	return __blkg_prfill_rwstat(sf, pd, &rwstat);
}
EXPORT_SYMBOL_GPL(blkg_prfill_rwstat);

/**
 * blkg_rwstat_recursive_sum - collect hierarchical blkg_rwstat
 * @blkg: blkg of interest
 * @pol: blkcg_policy which contains the blkg_rwstat
 * @off: offset to the blkg_rwstat in blkg_policy_data or @blkg
 * @sum: blkg_rwstat_sample structure containing the results
 *
 * Collect the blkg_rwstat specified by @blkg, @pol and @off and all its
 * online descendants and their aux counts.  The caller must be holding the
 * queue lock for online tests.
 *
 * If @pol is NULL, blkg_rwstat is at @off bytes into @blkg; otherwise, it
 * is at @off bytes into @blkg's blkg_policy_data of the policy.
 */
void blkg_rwstat_recursive_sum(struct blkcg_gq *blkg, struct blkcg_policy *pol,
		int off, struct blkg_rwstat_sample *sum)
{
	struct blkcg_gq *pos_blkg;
	struct cgroup_subsys_state *pos_css;
	unsigned int i;

	lockdep_assert_held(&blkg->q->queue_lock);

	memset(sum, 0, sizeof(*sum));
	rcu_read_lock();
	blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
		struct blkg_rwstat *rwstat;

		if (!pos_blkg->online)
			continue;

		if (pol)
			rwstat = (void *)blkg_to_pd(pos_blkg, pol) + off;
		else
			rwstat = (void *)pos_blkg + off;

		for (i = 0; i < BLKG_RWSTAT_NR; i++)
			sum->cnt[i] += blkg_rwstat_read_counter(rwstat, i);
	}
	rcu_read_unlock();
}
EXPORT_SYMBOL_GPL(blkg_rwstat_recursive_sum);
Commit	Line	Data
1d156646 TH	1	/* SPDX-License-Identifier: GPL-2.0
	2	*
	3	* Legacy blkg rwstat helpers enabled by CONFIG_BLK_CGROUP_RWSTAT.
	4	* Do not use in new code.
	5	*/
	6	#include "blk-cgroup-rwstat.h"
	7
	8	int blkg_rwstat_init(struct blkg_rwstat *rwstat, gfp_t gfp)
	9	{
	10	int i, ret;
	11
688c8b92 KW	12	ret = percpu_counter_init_many(rwstat->cpu_cnt, 0, gfp, BLKG_RWSTAT_NR);
	13	if (ret)
	14	return ret;
	15
	16	for (i = 0; i < BLKG_RWSTAT_NR; i++)
1d156646	17	atomic64_set(&rwstat->aux_cnt[i], 0);
1d156646 TH	18	return 0;
	19	}
	20	EXPORT_SYMBOL_GPL(blkg_rwstat_init);
	21
	22	void blkg_rwstat_exit(struct blkg_rwstat *rwstat)
	23	{
688c8b92	24	percpu_counter_destroy_many(rwstat->cpu_cnt, BLKG_RWSTAT_NR);
1d156646 TH	25	}
	26	EXPORT_SYMBOL_GPL(blkg_rwstat_exit);
	27
	28	/**
	29	* __blkg_prfill_rwstat - prfill helper for a blkg_rwstat
	30	* @sf: seq_file to print to
	31	* @pd: policy private data of interest
	32	* @rwstat: rwstat to print
	33	*
	34	* Print @rwstat to @sf for the device assocaited with @pd.
	35	*/
	36	u64 __blkg_prfill_rwstat(struct seq_file sf, struct blkg_policy_data pd,
	37	const struct blkg_rwstat_sample *rwstat)
	38	{
	39	static const char *rwstr[] = {
	40	[BLKG_RWSTAT_READ] = "Read",
	41	[BLKG_RWSTAT_WRITE] = "Write",
	42	[BLKG_RWSTAT_SYNC] = "Sync",
	43	[BLKG_RWSTAT_ASYNC] = "Async",
	44	[BLKG_RWSTAT_DISCARD] = "Discard",
	45	};
	46	const char *dname = blkg_dev_name(pd->blkg);
	47	u64 v;
	48	int i;
	49
	50	if (!dname)
	51	return 0;
	52
	53	for (i = 0; i < BLKG_RWSTAT_NR; i++)
	54	seq_printf(sf, "%s %s %llu\n", dname, rwstr[i],
	55	rwstat->cnt[i]);
	56
	57	v = rwstat->cnt[BLKG_RWSTAT_READ] +
	58	rwstat->cnt[BLKG_RWSTAT_WRITE] +
	59	rwstat->cnt[BLKG_RWSTAT_DISCARD];
	60	seq_printf(sf, "%s Total %llu\n", dname, v);
	61	return v;
	62	}
	63	EXPORT_SYMBOL_GPL(__blkg_prfill_rwstat);
	64
	65	/**
	66	* blkg_prfill_rwstat - prfill callback for blkg_rwstat
	67	* @sf: seq_file to print to
	68	* @pd: policy private data of interest
	69	* @off: offset to the blkg_rwstat in @pd
	70	*
	71	* prfill callback for printing a blkg_rwstat.
	72	*/
	73	u64 blkg_prfill_rwstat(struct seq_file sf, struct blkg_policy_data pd,
	74	int off)
	75	{
	76	struct blkg_rwstat_sample rwstat = { };
	77
	78	blkg_rwstat_read((void *)pd + off, &rwstat);
	79	return __blkg_prfill_rwstat(sf, pd, &rwstat);
	80	}
	81	EXPORT_SYMBOL_GPL(blkg_prfill_rwstat);
	82
	83	/**
	84	* blkg_rwstat_recursive_sum - collect hierarchical blkg_rwstat
	85	* @blkg: blkg of interest
	86	* @pol: blkcg_policy which contains the blkg_rwstat
	87	* @off: offset to the blkg_rwstat in blkg_policy_data or @blkg
	88	* @sum: blkg_rwstat_sample structure containing the results
89	*
90	* Collect the blkg_rwstat specified by @blkg, @pol and @off and all its
91	* online descendants and their aux counts. The caller must be holding the
92	* queue lock for online tests.
93	*
94	* If @pol is NULL, blkg_rwstat is at @off bytes into @blkg; otherwise, it
95	* is at @off bytes into @blkg's blkg_policy_data of the policy.
96	*/
97	void blkg_rwstat_recursive_sum(struct blkcg_gq blkg, struct blkcg_policy pol,
98	int off, struct blkg_rwstat_sample *sum)
99	{
100	struct blkcg_gq *pos_blkg;
101	struct cgroup_subsys_state *pos_css;
102	unsigned int i;
103
104	lockdep_assert_held(&blkg->q->queue_lock);
105
4f44657d	106	memset(sum, 0, sizeof(*sum));
1d156646 TH	107	rcu_read_lock();
	108	blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
	109	struct blkg_rwstat *rwstat;
	110
	111	if (!pos_blkg->online)
	112	continue;
	113
	114	if (pol)
	115	rwstat = (void *)blkg_to_pd(pos_blkg, pol) + off;
	116	else
	117	rwstat = (void *)pos_blkg + off;
	118
	119	for (i = 0; i < BLKG_RWSTAT_NR; i++)
4f44657d	120	sum->cnt[i] += blkg_rwstat_read_counter(rwstat, i);
1d156646 TH	121	}
	122	rcu_read_unlock();
	123	}
	124	EXPORT_SYMBOL_GPL(blkg_rwstat_recursive_sum);