[linux-2.6-block.git] / kernel / cgroup / rstat.c

// SPDX-License-Identifier: GPL-2.0-only
#include "cgroup-internal.h"

#include <linux/sched/cputime.h>

static DEFINE_SPINLOCK(cgroup_rstat_lock);
static DEFINE_PER_CPU(raw_spinlock_t, cgroup_rstat_cpu_lock);

static void cgroup_base_stat_flush(struct cgroup *cgrp, int cpu);

static struct cgroup_rstat_cpu *cgroup_rstat_cpu(struct cgroup *cgrp, int cpu)
{
	return per_cpu_ptr(cgrp->rstat_cpu, cpu);
}

/**
 * cgroup_rstat_updated - keep track of updated rstat_cpu
 * @cgrp: target cgroup
 * @cpu: cpu on which rstat_cpu was updated
 *
 * @cgrp's rstat_cpu on @cpu was updated.  Put it on the parent's matching
 * rstat_cpu->updated_children list.  See the comment on top of
 * cgroup_rstat_cpu definition for details.
 */
void cgroup_rstat_updated(struct cgroup *cgrp, int cpu)
{
	raw_spinlock_t *cpu_lock = per_cpu_ptr(&cgroup_rstat_cpu_lock, cpu);
	struct cgroup *parent;
	unsigned long flags;

	/* nothing to do for root */
	if (!cgroup_parent(cgrp))
		return;

	/*
	 * Paired with the one in cgroup_rstat_cpu_pop_upated().  Either we
	 * see NULL updated_next or they see our updated stat.
	 */
	smp_mb();

	/*
	 * Because @parent's updated_children is terminated with @parent
	 * instead of NULL, we can tell whether @cgrp is on the list by
	 * testing the next pointer for NULL.
	 */
	if (cgroup_rstat_cpu(cgrp, cpu)->updated_next)
		return;

	raw_spin_lock_irqsave(cpu_lock, flags);

	/* put @cgrp and all ancestors on the corresponding updated lists */
	for (parent = cgroup_parent(cgrp); parent;
	     cgrp = parent, parent = cgroup_parent(cgrp)) {
		struct cgroup_rstat_cpu *rstatc = cgroup_rstat_cpu(cgrp, cpu);
		struct cgroup_rstat_cpu *prstatc = cgroup_rstat_cpu(parent, cpu);

		/*
		 * Both additions and removals are bottom-up.  If a cgroup
		 * is already in the tree, all ancestors are.
		 */
		if (rstatc->updated_next)
			break;

		rstatc->updated_next = prstatc->updated_children;
		prstatc->updated_children = cgrp;
	}

	raw_spin_unlock_irqrestore(cpu_lock, flags);
}
EXPORT_SYMBOL_GPL(cgroup_rstat_updated);

/**
 * cgroup_rstat_cpu_pop_updated - iterate and dismantle rstat_cpu updated tree
 * @pos: current position
 * @root: root of the tree to traversal
 * @cpu: target cpu
 *
 * Walks the udpated rstat_cpu tree on @cpu from @root.  %NULL @pos starts
 * the traversal and %NULL return indicates the end.  During traversal,
 * each returned cgroup is unlinked from the tree.  Must be called with the
 * matching cgroup_rstat_cpu_lock held.
 *
 * The only ordering guarantee is that, for a parent and a child pair
 * covered by a given traversal, if a child is visited, its parent is
 * guaranteed to be visited afterwards.
 */
static struct cgroup *cgroup_rstat_cpu_pop_updated(struct cgroup *pos,
						   struct cgroup *root, int cpu)
{
	struct cgroup_rstat_cpu *rstatc;

	if (pos == root)
		return NULL;

	/*
	 * We're gonna walk down to the first leaf and visit/remove it.  We
	 * can pick whatever unvisited node as the starting point.
	 */
	if (!pos)
		pos = root;
	else
		pos = cgroup_parent(pos);

	/* walk down to the first leaf */
	while (true) {
		rstatc = cgroup_rstat_cpu(pos, cpu);
		if (rstatc->updated_children == pos)
			break;
		pos = rstatc->updated_children;
	}

	/*
	 * Unlink @pos from the tree.  As the updated_children list is
	 * singly linked, we have to walk it to find the removal point.
	 * However, due to the way we traverse, @pos will be the first
	 * child in most cases. The only exception is @root.
	 */
	if (rstatc->updated_next) {
		struct cgroup *parent = cgroup_parent(pos);
		struct cgroup_rstat_cpu *prstatc = cgroup_rstat_cpu(parent, cpu);
		struct cgroup_rstat_cpu *nrstatc;
		struct cgroup **nextp;

		nextp = &prstatc->updated_children;
		while (true) {
			nrstatc = cgroup_rstat_cpu(*nextp, cpu);
			if (*nextp == pos)
				break;

			WARN_ON_ONCE(*nextp == parent);
			nextp = &nrstatc->updated_next;
		}

		*nextp = rstatc->updated_next;
		rstatc->updated_next = NULL;

		/*
		 * Paired with the one in cgroup_rstat_cpu_updated().
		 * Either they see NULL updated_next or we see their
		 * updated stat.
		 */
		smp_mb();

		return pos;
	}

	/* only happens for @root */
	return NULL;
}

/* see cgroup_rstat_flush() */
static void cgroup_rstat_flush_locked(struct cgroup *cgrp, bool may_sleep)
	__releases(&cgroup_rstat_lock) __acquires(&cgroup_rstat_lock)
{
	int cpu;

	lockdep_assert_held(&cgroup_rstat_lock);

	for_each_possible_cpu(cpu) {
		raw_spinlock_t *cpu_lock = per_cpu_ptr(&cgroup_rstat_cpu_lock,
						       cpu);
		struct cgroup *pos = NULL;

		raw_spin_lock(cpu_lock);
		while ((pos = cgroup_rstat_cpu_pop_updated(pos, cgrp, cpu))) {
			struct cgroup_subsys_state *css;

			cgroup_base_stat_flush(pos, cpu);

			rcu_read_lock();
			list_for_each_entry_rcu(css, &pos->rstat_css_list,
						rstat_css_node)
				css->ss->css_rstat_flush(css, cpu);
			rcu_read_unlock();
		}
		raw_spin_unlock(cpu_lock);

		/* if @may_sleep, play nice and yield if necessary */
		if (may_sleep && (need_resched() ||
				  spin_needbreak(&cgroup_rstat_lock))) {
			spin_unlock_irq(&cgroup_rstat_lock);
			if (!cond_resched())
				cpu_relax();
			spin_lock_irq(&cgroup_rstat_lock);
		}
	}
}

/**
 * cgroup_rstat_flush - flush stats in @cgrp's subtree
 * @cgrp: target cgroup
 *
 * Collect all per-cpu stats in @cgrp's subtree into the global counters
 * and propagate them upwards.  After this function returns, all cgroups in
 * the subtree have up-to-date ->stat.
 *
 * This also gets all cgroups in the subtree including @cgrp off the
 * ->updated_children lists.
 *
 * This function may block.
 */
void cgroup_rstat_flush(struct cgroup *cgrp)
{
	might_sleep();

	spin_lock_irq(&cgroup_rstat_lock);
	cgroup_rstat_flush_locked(cgrp, true);
	spin_unlock_irq(&cgroup_rstat_lock);
}

/**
 * cgroup_rstat_flush_irqsafe - irqsafe version of cgroup_rstat_flush()
 * @cgrp: target cgroup
 *
 * This function can be called from any context.
 */
void cgroup_rstat_flush_irqsafe(struct cgroup *cgrp)
{
	unsigned long flags;

	spin_lock_irqsave(&cgroup_rstat_lock, flags);
	cgroup_rstat_flush_locked(cgrp, false);
	spin_unlock_irqrestore(&cgroup_rstat_lock, flags);
}

/**
 * cgroup_rstat_flush_begin - flush stats in @cgrp's subtree and hold
 * @cgrp: target cgroup
 *
 * Flush stats in @cgrp's subtree and prevent further flushes.  Must be
 * paired with cgroup_rstat_flush_release().
 *
 * This function may block.
 */
void cgroup_rstat_flush_hold(struct cgroup *cgrp)
	__acquires(&cgroup_rstat_lock)
{
	might_sleep();
	spin_lock_irq(&cgroup_rstat_lock);
	cgroup_rstat_flush_locked(cgrp, true);
}

/**
 * cgroup_rstat_flush_release - release cgroup_rstat_flush_hold()
 */
void cgroup_rstat_flush_release(void)
	__releases(&cgroup_rstat_lock)
{
	spin_unlock_irq(&cgroup_rstat_lock);
}

int cgroup_rstat_init(struct cgroup *cgrp)
{
	int cpu;

	/* the root cgrp has rstat_cpu preallocated */
	if (!cgrp->rstat_cpu) {
		cgrp->rstat_cpu = alloc_percpu(struct cgroup_rstat_cpu);
		if (!cgrp->rstat_cpu)
			return -ENOMEM;
	}

	/* ->updated_children list is self terminated */
	for_each_possible_cpu(cpu) {
		struct cgroup_rstat_cpu *rstatc = cgroup_rstat_cpu(cgrp, cpu);

		rstatc->updated_children = cgrp;
		u64_stats_init(&rstatc->bsync);
	}

	return 0;
}

void cgroup_rstat_exit(struct cgroup *cgrp)
{
	int cpu;

	cgroup_rstat_flush(cgrp);

	/* sanity check */
	for_each_possible_cpu(cpu) {
		struct cgroup_rstat_cpu *rstatc = cgroup_rstat_cpu(cgrp, cpu);

		if (WARN_ON_ONCE(rstatc->updated_children != cgrp) ||
		    WARN_ON_ONCE(rstatc->updated_next))
			return;
	}

	free_percpu(cgrp->rstat_cpu);
	cgrp->rstat_cpu = NULL;
}

void __init cgroup_rstat_boot(void)
{
	int cpu;

	for_each_possible_cpu(cpu)
		raw_spin_lock_init(per_cpu_ptr(&cgroup_rstat_cpu_lock, cpu));

	BUG_ON(cgroup_rstat_init(&cgrp_dfl_root.cgrp));
}

/*
 * Functions for cgroup basic resource statistics implemented on top of
 * rstat.
 */
static void cgroup_base_stat_accumulate(struct cgroup_base_stat *dst_bstat,
					struct cgroup_base_stat *src_bstat)
{
	dst_bstat->cputime.utime += src_bstat->cputime.utime;
	dst_bstat->cputime.stime += src_bstat->cputime.stime;
	dst_bstat->cputime.sum_exec_runtime += src_bstat->cputime.sum_exec_runtime;
}

static void cgroup_base_stat_flush(struct cgroup *cgrp, int cpu)
{
	struct cgroup *parent = cgroup_parent(cgrp);
	struct cgroup_rstat_cpu *rstatc = cgroup_rstat_cpu(cgrp, cpu);
	struct task_cputime *last_cputime = &rstatc->last_bstat.cputime;
	struct task_cputime cputime;
	struct cgroup_base_stat delta;
	unsigned seq;

	/* fetch the current per-cpu values */
	do {
		seq = __u64_stats_fetch_begin(&rstatc->bsync);
		cputime = rstatc->bstat.cputime;
	} while (__u64_stats_fetch_retry(&rstatc->bsync, seq));

	/* calculate the delta to propgate */
	delta.cputime.utime = cputime.utime - last_cputime->utime;
	delta.cputime.stime = cputime.stime - last_cputime->stime;
	delta.cputime.sum_exec_runtime = cputime.sum_exec_runtime -
					 last_cputime->sum_exec_runtime;
	*last_cputime = cputime;

	/* transfer the pending stat into delta */
	cgroup_base_stat_accumulate(&delta, &cgrp->pending_bstat);
	memset(&cgrp->pending_bstat, 0, sizeof(cgrp->pending_bstat));

	/* propagate delta into the global stat and the parent's pending */
	cgroup_base_stat_accumulate(&cgrp->bstat, &delta);
	if (parent)
		cgroup_base_stat_accumulate(&parent->pending_bstat, &delta);
}

static struct cgroup_rstat_cpu *
cgroup_base_stat_cputime_account_begin(struct cgroup *cgrp)
{
	struct cgroup_rstat_cpu *rstatc;

	rstatc = get_cpu_ptr(cgrp->rstat_cpu);
	u64_stats_update_begin(&rstatc->bsync);
	return rstatc;
}

static void cgroup_base_stat_cputime_account_end(struct cgroup *cgrp,
						 struct cgroup_rstat_cpu *rstatc)
{
	u64_stats_update_end(&rstatc->bsync);
	cgroup_rstat_updated(cgrp, smp_processor_id());
	put_cpu_ptr(rstatc);
}

void __cgroup_account_cputime(struct cgroup *cgrp, u64 delta_exec)
{
	struct cgroup_rstat_cpu *rstatc;

	rstatc = cgroup_base_stat_cputime_account_begin(cgrp);
	rstatc->bstat.cputime.sum_exec_runtime += delta_exec;
	cgroup_base_stat_cputime_account_end(cgrp, rstatc);
}

void __cgroup_account_cputime_field(struct cgroup *cgrp,
				    enum cpu_usage_stat index, u64 delta_exec)
{
	struct cgroup_rstat_cpu *rstatc;

	rstatc = cgroup_base_stat_cputime_account_begin(cgrp);

	switch (index) {
	case CPUTIME_USER:
	case CPUTIME_NICE:
		rstatc->bstat.cputime.utime += delta_exec;
		break;
	case CPUTIME_SYSTEM:
	case CPUTIME_IRQ:
	case CPUTIME_SOFTIRQ:
		rstatc->bstat.cputime.stime += delta_exec;
		break;
	default:
		break;
	}

	cgroup_base_stat_cputime_account_end(cgrp, rstatc);
}

void cgroup_base_stat_cputime_show(struct seq_file *seq)
{
	struct cgroup *cgrp = seq_css(seq)->cgroup;
	u64 usage, utime, stime;

	if (!cgroup_parent(cgrp))
		return;

	cgroup_rstat_flush_hold(cgrp);
	usage = cgrp->bstat.cputime.sum_exec_runtime;
	cputime_adjust(&cgrp->bstat.cputime, &cgrp->prev_cputime, &utime, &stime);
	cgroup_rstat_flush_release();

	do_div(usage, NSEC_PER_USEC);
	do_div(utime, NSEC_PER_USEC);
	do_div(stime, NSEC_PER_USEC);

	seq_printf(seq, "usage_usec %llu\n"
		   "user_usec %llu\n"
		   "system_usec %llu\n",
		   usage, utime, stime);
}
Commit	Line	Data
457c8996	1	// SPDX-License-Identifier: GPL-2.0-only
041cd640 TH	2	#include "cgroup-internal.h"
	3
	4	#include <linux/sched/cputime.h>
	5
0fa294fb	6	static DEFINE_SPINLOCK(cgroup_rstat_lock);
c58632b3	7	static DEFINE_PER_CPU(raw_spinlock_t, cgroup_rstat_cpu_lock);
041cd640	8
a17556f8 TH	9	static void cgroup_base_stat_flush(struct cgroup *cgrp, int cpu);
a17556f8 TH	10
c58632b3	11	static struct cgroup_rstat_cpu cgroup_rstat_cpu(struct cgroup cgrp, int cpu)
041cd640	12	{
c58632b3	13	return per_cpu_ptr(cgrp->rstat_cpu, cpu);
041cd640 TH	14	}
	15
	16	/**
6162cef0	17	* cgroup_rstat_updated - keep track of updated rstat_cpu
041cd640	18	* @cgrp: target cgroup
c58632b3	19	* @cpu: cpu on which rstat_cpu was updated
041cd640	20	*
c58632b3 TH	21	* @cgrp's rstat_cpu on @cpu was updated. Put it on the parent's matching
	22	* rstat_cpu->updated_children list. See the comment on top of
	23	* cgroup_rstat_cpu definition for details.
041cd640	24	*/
6162cef0	25	void cgroup_rstat_updated(struct cgroup *cgrp, int cpu)
041cd640	26	{
c58632b3	27	raw_spinlock_t *cpu_lock = per_cpu_ptr(&cgroup_rstat_cpu_lock, cpu);
041cd640 TH	28	struct cgroup *parent;
	29	unsigned long flags;
	30
c43c5ea7 TH	31	/* nothing to do for root */
	32	if (!cgroup_parent(cgrp))
	33	return;
	34
041cd640	35	/*
9a9e97b2 TH	36	* Paired with the one in cgroup_rstat_cpu_pop_upated(). Either we
	37	* see NULL updated_next or they see our updated stat.
	38	*/
	39	smp_mb();
	40
	41	/*
041cd640 TH	42	* Because @parent's updated_children is terminated with @parent
	43	* instead of NULL, we can tell whether @cgrp is on the list by
	44	* testing the next pointer for NULL.
	45	*/
c58632b3	46	if (cgroup_rstat_cpu(cgrp, cpu)->updated_next)
041cd640 TH	47	return;
	48
	49	raw_spin_lock_irqsave(cpu_lock, flags);
	50
	51	/* put @cgrp and all ancestors on the corresponding updated lists */
	52	for (parent = cgroup_parent(cgrp); parent;
	53	cgrp = parent, parent = cgroup_parent(cgrp)) {
c58632b3 TH	54	struct cgroup_rstat_cpu *rstatc = cgroup_rstat_cpu(cgrp, cpu);
c58632b3 TH	55	struct cgroup_rstat_cpu *prstatc = cgroup_rstat_cpu(parent, cpu);
041cd640 TH	56
	57	/*
	58	* Both additions and removals are bottom-up. If a cgroup
	59	* is already in the tree, all ancestors are.
	60	*/
c58632b3	61	if (rstatc->updated_next)
041cd640 TH	62	break;
041cd640 TH	63
c58632b3 TH	64	rstatc->updated_next = prstatc->updated_children;
c58632b3 TH	65	prstatc->updated_children = cgrp;
041cd640 TH	66	}
	67
	68	raw_spin_unlock_irqrestore(cpu_lock, flags);
	69	}
6162cef0	70	EXPORT_SYMBOL_GPL(cgroup_rstat_updated);
041cd640 TH	71
041cd640 TH	72	/**
c58632b3	73	* cgroup_rstat_cpu_pop_updated - iterate and dismantle rstat_cpu updated tree
041cd640 TH	74	* @pos: current position
	75	* @root: root of the tree to traversal
	76	* @cpu: target cpu
	77	*
c58632b3	78	* Walks the udpated rstat_cpu tree on @cpu from @root. %NULL @pos starts
041cd640 TH	79	* the traversal and %NULL return indicates the end. During traversal,
041cd640 TH	80	* each returned cgroup is unlinked from the tree. Must be called with the
c58632b3	81	* matching cgroup_rstat_cpu_lock held.
041cd640 TH	82	*
	83	* The only ordering guarantee is that, for a parent and a child pair
	84	* covered by a given traversal, if a child is visited, its parent is
	85	* guaranteed to be visited afterwards.
	86	*/
c58632b3 TH	87	static struct cgroup cgroup_rstat_cpu_pop_updated(struct cgroup pos,
c58632b3 TH	88	struct cgroup *root, int cpu)
041cd640	89	{
c58632b3	90	struct cgroup_rstat_cpu *rstatc;
041cd640 TH	91
	92	if (pos == root)
	93	return NULL;
	94
	95	/*
	96	* We're gonna walk down to the first leaf and visit/remove it. We
	97	* can pick whatever unvisited node as the starting point.
	98	*/
	99	if (!pos)
	100	pos = root;
	101	else
	102	pos = cgroup_parent(pos);
	103
	104	/* walk down to the first leaf */
	105	while (true) {
c58632b3 TH	106	rstatc = cgroup_rstat_cpu(pos, cpu);
c58632b3 TH	107	if (rstatc->updated_children == pos)
041cd640	108	break;
c58632b3	109	pos = rstatc->updated_children;
041cd640 TH	110	}
	111
	112	/*
	113	* Unlink @pos from the tree. As the updated_children list is
	114	* singly linked, we have to walk it to find the removal point.
	115	* However, due to the way we traverse, @pos will be the first
	116	* child in most cases. The only exception is @root.
	117	*/
b4ff1b44 TH	118	if (rstatc->updated_next) {
b4ff1b44 TH	119	struct cgroup *parent = cgroup_parent(pos);
c58632b3 TH	120	struct cgroup_rstat_cpu *prstatc = cgroup_rstat_cpu(parent, cpu);
c58632b3 TH	121	struct cgroup_rstat_cpu *nrstatc;
041cd640 TH	122	struct cgroup **nextp;
041cd640 TH	123
c58632b3	124	nextp = &prstatc->updated_children;
041cd640	125	while (true) {
c58632b3	126	nrstatc = cgroup_rstat_cpu(*nextp, cpu);
041cd640 TH	127	if (*nextp == pos)
	128	break;
	129
	130	WARN_ON_ONCE(*nextp == parent);
c58632b3	131	nextp = &nrstatc->updated_next;
041cd640 TH	132	}
041cd640 TH	133
c58632b3 TH	134	*nextp = rstatc->updated_next;
c58632b3 TH	135	rstatc->updated_next = NULL;
9a9e97b2 TH	136
	137	/*
	138	* Paired with the one in cgroup_rstat_cpu_updated().
	139	* Either they see NULL updated_next or we see their
	140	* updated stat.
	141	*/
	142	smp_mb();
b4ff1b44 TH	143
b4ff1b44 TH	144	return pos;
041cd640 TH	145	}
041cd640 TH	146
b4ff1b44 TH	147	/* only happens for @root */
b4ff1b44 TH	148	return NULL;
041cd640 TH	149	}
041cd640 TH	150
a17556f8	151	/* see cgroup_rstat_flush() */
0fa294fb TH	152	static void cgroup_rstat_flush_locked(struct cgroup *cgrp, bool may_sleep)
0fa294fb TH	153	__releases(&cgroup_rstat_lock) __acquires(&cgroup_rstat_lock)
a17556f8 TH	154	{
	155	int cpu;
	156
0fa294fb	157	lockdep_assert_held(&cgroup_rstat_lock);
a17556f8 TH	158
	159	for_each_possible_cpu(cpu) {
	160	raw_spinlock_t *cpu_lock = per_cpu_ptr(&cgroup_rstat_cpu_lock,
	161	cpu);
	162	struct cgroup *pos = NULL;
	163
0fa294fb	164	raw_spin_lock(cpu_lock);
8f53470b TH	165	while ((pos = cgroup_rstat_cpu_pop_updated(pos, cgrp, cpu))) {
	166	struct cgroup_subsys_state *css;
	167
a17556f8	168	cgroup_base_stat_flush(pos, cpu);
8f53470b TH	169
	170	rcu_read_lock();
	171	list_for_each_entry_rcu(css, &pos->rstat_css_list,
	172	rstat_css_node)
	173	css->ss->css_rstat_flush(css, cpu);
	174	rcu_read_unlock();
	175	}
0fa294fb TH	176	raw_spin_unlock(cpu_lock);
	177
	178	/* if @may_sleep, play nice and yield if necessary */
	179	if (may_sleep && (need_resched() \|\|
	180	spin_needbreak(&cgroup_rstat_lock))) {
	181	spin_unlock_irq(&cgroup_rstat_lock);
	182	if (!cond_resched())
	183	cpu_relax();
	184	spin_lock_irq(&cgroup_rstat_lock);
	185	}
a17556f8 TH	186	}
	187	}
	188
	189	/**
	190	* cgroup_rstat_flush - flush stats in @cgrp's subtree
	191	* @cgrp: target cgroup
	192	*
	193	* Collect all per-cpu stats in @cgrp's subtree into the global counters
	194	* and propagate them upwards. After this function returns, all cgroups in
	195	* the subtree have up-to-date ->stat.
	196	*
	197	* This also gets all cgroups in the subtree including @cgrp off the
	198	* ->updated_children lists.
0fa294fb TH	199	*
0fa294fb TH	200	* This function may block.
a17556f8 TH	201	*/
	202	void cgroup_rstat_flush(struct cgroup *cgrp)
	203	{
0fa294fb TH	204	might_sleep();
	205
	206	spin_lock_irq(&cgroup_rstat_lock);
	207	cgroup_rstat_flush_locked(cgrp, true);
	208	spin_unlock_irq(&cgroup_rstat_lock);
	209	}
	210
	211	/**
	212	* cgroup_rstat_flush_irqsafe - irqsafe version of cgroup_rstat_flush()
	213	* @cgrp: target cgroup
	214	*
	215	* This function can be called from any context.
	216	*/
	217	void cgroup_rstat_flush_irqsafe(struct cgroup *cgrp)
	218	{
	219	unsigned long flags;
	220
	221	spin_lock_irqsave(&cgroup_rstat_lock, flags);
	222	cgroup_rstat_flush_locked(cgrp, false);
	223	spin_unlock_irqrestore(&cgroup_rstat_lock, flags);
a17556f8 TH	224	}
a17556f8 TH	225
6162cef0 TH	226	/**
	227	* cgroup_rstat_flush_begin - flush stats in @cgrp's subtree and hold
	228	* @cgrp: target cgroup
	229	*
	230	* Flush stats in @cgrp's subtree and prevent further flushes. Must be
	231	* paired with cgroup_rstat_flush_release().
0fa294fb TH	232	*
0fa294fb TH	233	* This function may block.
6162cef0 TH	234	*/
6162cef0 TH	235	void cgroup_rstat_flush_hold(struct cgroup *cgrp)
0fa294fb	236	__acquires(&cgroup_rstat_lock)
6162cef0	237	{
0fa294fb TH	238	might_sleep();
	239	spin_lock_irq(&cgroup_rstat_lock);
	240	cgroup_rstat_flush_locked(cgrp, true);
6162cef0 TH	241	}
	242
	243	/**
	244	* cgroup_rstat_flush_release - release cgroup_rstat_flush_hold()
	245	*/
	246	void cgroup_rstat_flush_release(void)
0fa294fb	247	__releases(&cgroup_rstat_lock)
6162cef0	248	{
0fa294fb	249	spin_unlock_irq(&cgroup_rstat_lock);
6162cef0 TH	250	}
6162cef0 TH	251
a17556f8 TH	252	int cgroup_rstat_init(struct cgroup *cgrp)
	253	{
	254	int cpu;
	255
	256	/* the root cgrp has rstat_cpu preallocated */
	257	if (!cgrp->rstat_cpu) {
	258	cgrp->rstat_cpu = alloc_percpu(struct cgroup_rstat_cpu);
	259	if (!cgrp->rstat_cpu)
	260	return -ENOMEM;
	261	}
	262
	263	/* ->updated_children list is self terminated */
	264	for_each_possible_cpu(cpu) {
	265	struct cgroup_rstat_cpu *rstatc = cgroup_rstat_cpu(cgrp, cpu);
	266
	267	rstatc->updated_children = cgrp;
	268	u64_stats_init(&rstatc->bsync);
	269	}
	270
	271	return 0;
	272	}
	273
	274	void cgroup_rstat_exit(struct cgroup *cgrp)
	275	{
	276	int cpu;
	277
	278	cgroup_rstat_flush(cgrp);
	279
	280	/* sanity check */
	281	for_each_possible_cpu(cpu) {
	282	struct cgroup_rstat_cpu *rstatc = cgroup_rstat_cpu(cgrp, cpu);
	283
	284	if (WARN_ON_ONCE(rstatc->updated_children != cgrp) \|\|
	285	WARN_ON_ONCE(rstatc->updated_next))
	286	return;
	287	}
	288
	289	free_percpu(cgrp->rstat_cpu);
	290	cgrp->rstat_cpu = NULL;
	291	}
	292
	293	void __init cgroup_rstat_boot(void)
	294	{
	295	int cpu;
	296
	297	for_each_possible_cpu(cpu)
	298	raw_spin_lock_init(per_cpu_ptr(&cgroup_rstat_cpu_lock, cpu));
	299
	300	BUG_ON(cgroup_rstat_init(&cgrp_dfl_root.cgrp));
	301	}
	302
	303	/*
	304	* Functions for cgroup basic resource statistics implemented on top of
	305	* rstat.
	306	*/
d4ff749b TH	307	static void cgroup_base_stat_accumulate(struct cgroup_base_stat *dst_bstat,
d4ff749b TH	308	struct cgroup_base_stat *src_bstat)
041cd640	309	{
d4ff749b TH	310	dst_bstat->cputime.utime += src_bstat->cputime.utime;
	311	dst_bstat->cputime.stime += src_bstat->cputime.stime;
	312	dst_bstat->cputime.sum_exec_runtime += src_bstat->cputime.sum_exec_runtime;
041cd640 TH	313	}
041cd640 TH	314
d4ff749b	315	static void cgroup_base_stat_flush(struct cgroup *cgrp, int cpu)
041cd640 TH	316	{
041cd640 TH	317	struct cgroup *parent = cgroup_parent(cgrp);
c58632b3	318	struct cgroup_rstat_cpu *rstatc = cgroup_rstat_cpu(cgrp, cpu);
d4ff749b	319	struct task_cputime *last_cputime = &rstatc->last_bstat.cputime;
041cd640	320	struct task_cputime cputime;
d4ff749b	321	struct cgroup_base_stat delta;
041cd640 TH	322	unsigned seq;
041cd640 TH	323
041cd640 TH	324	/* fetch the current per-cpu values */
041cd640 TH	325	do {
d4ff749b TH	326	seq = __u64_stats_fetch_begin(&rstatc->bsync);
	327	cputime = rstatc->bstat.cputime;
	328	} while (__u64_stats_fetch_retry(&rstatc->bsync, seq));
041cd640	329
6162cef0	330	/* calculate the delta to propgate */
041cd640 TH	331	delta.cputime.utime = cputime.utime - last_cputime->utime;
	332	delta.cputime.stime = cputime.stime - last_cputime->stime;
	333	delta.cputime.sum_exec_runtime = cputime.sum_exec_runtime -
	334	last_cputime->sum_exec_runtime;
	335	*last_cputime = cputime;
	336
	337	/* transfer the pending stat into delta */
d4ff749b TH	338	cgroup_base_stat_accumulate(&delta, &cgrp->pending_bstat);
d4ff749b TH	339	memset(&cgrp->pending_bstat, 0, sizeof(cgrp->pending_bstat));
041cd640 TH	340
041cd640 TH	341	/* propagate delta into the global stat and the parent's pending */
d4ff749b	342	cgroup_base_stat_accumulate(&cgrp->bstat, &delta);
041cd640	343	if (parent)
d4ff749b	344	cgroup_base_stat_accumulate(&parent->pending_bstat, &delta);
041cd640 TH	345	}
041cd640 TH	346
c58632b3	347	static struct cgroup_rstat_cpu *
d4ff749b	348	cgroup_base_stat_cputime_account_begin(struct cgroup *cgrp)
041cd640	349	{
c58632b3	350	struct cgroup_rstat_cpu *rstatc;
041cd640	351
c58632b3	352	rstatc = get_cpu_ptr(cgrp->rstat_cpu);
d4ff749b	353	u64_stats_update_begin(&rstatc->bsync);
c58632b3	354	return rstatc;
041cd640 TH	355	}
041cd640 TH	356
d4ff749b TH	357	static void cgroup_base_stat_cputime_account_end(struct cgroup *cgrp,
d4ff749b TH	358	struct cgroup_rstat_cpu *rstatc)
041cd640	359	{
d4ff749b	360	u64_stats_update_end(&rstatc->bsync);
6162cef0	361	cgroup_rstat_updated(cgrp, smp_processor_id());
c58632b3	362	put_cpu_ptr(rstatc);
041cd640 TH	363	}
	364
	365	void __cgroup_account_cputime(struct cgroup *cgrp, u64 delta_exec)
	366	{
c58632b3	367	struct cgroup_rstat_cpu *rstatc;
041cd640	368
d4ff749b TH	369	rstatc = cgroup_base_stat_cputime_account_begin(cgrp);
	370	rstatc->bstat.cputime.sum_exec_runtime += delta_exec;
	371	cgroup_base_stat_cputime_account_end(cgrp, rstatc);
041cd640 TH	372	}
	373
	374	void __cgroup_account_cputime_field(struct cgroup *cgrp,
	375	enum cpu_usage_stat index, u64 delta_exec)
	376	{
c58632b3	377	struct cgroup_rstat_cpu *rstatc;
041cd640	378
d4ff749b	379	rstatc = cgroup_base_stat_cputime_account_begin(cgrp);
041cd640 TH	380
	381	switch (index) {
	382	case CPUTIME_USER:
	383	case CPUTIME_NICE:
d4ff749b	384	rstatc->bstat.cputime.utime += delta_exec;
041cd640 TH	385	break;
	386	case CPUTIME_SYSTEM:
	387	case CPUTIME_IRQ:
	388	case CPUTIME_SOFTIRQ:
d4ff749b	389	rstatc->bstat.cputime.stime += delta_exec;
041cd640 TH	390	break;
	391	default:
	392	break;
	393	}
	394
d4ff749b	395	cgroup_base_stat_cputime_account_end(cgrp, rstatc);
041cd640 TH	396	}
041cd640 TH	397
d4ff749b	398	void cgroup_base_stat_cputime_show(struct seq_file *seq)
041cd640 TH	399	{
	400	struct cgroup *cgrp = seq_css(seq)->cgroup;
	401	u64 usage, utime, stime;
	402
	403	if (!cgroup_parent(cgrp))
	404	return;
	405
6162cef0	406	cgroup_rstat_flush_hold(cgrp);
d4ff749b TH	407	usage = cgrp->bstat.cputime.sum_exec_runtime;
d4ff749b TH	408	cputime_adjust(&cgrp->bstat.cputime, &cgrp->prev_cputime, &utime, &stime);
6162cef0	409	cgroup_rstat_flush_release();
041cd640 TH	410
	411	do_div(usage, NSEC_PER_USEC);
	412	do_div(utime, NSEC_PER_USEC);
	413	do_div(stime, NSEC_PER_USEC);
	414
d41bf8c9 TH	415	seq_printf(seq, "usage_usec %llu\n"
	416	"user_usec %llu\n"
	417	"system_usec %llu\n",
	418	usage, utime, stime);
041cd640	419	}