[deliverable/linux.git] / kernel / cpu_acct.c

/*
 * kernel/cpu_acct.c - CPU accounting cgroup subsystem
 *
 * Copyright (C) Google Inc, 2006
 *
 * Developed by Paul Menage (menage@google.com) and Balbir Singh
 * (balbir@in.ibm.com)
 *
 */

/*
 * Example cgroup subsystem for reporting total CPU usage of tasks in a
 * cgroup, along with percentage load over a time interval
 */

#include <linux/module.h>
#include <linux/cgroup.h>
#include <linux/fs.h>
#include <linux/rcupdate.h>

#include <asm/div64.h>

struct cpuacct {
	struct cgroup_subsys_state css;
	spinlock_t lock;
	/* total time used by this class */
	cputime64_t time;

	/* time when next load calculation occurs */
	u64 next_interval_check;

	/* time used in current period */
	cputime64_t current_interval_time;

	/* time used in last period */
	cputime64_t last_interval_time;
};

struct cgroup_subsys cpuacct_subsys;

static inline struct cpuacct *cgroup_ca(struct cgroup *cont)
{
	return container_of(cgroup_subsys_state(cont, cpuacct_subsys_id),
			    struct cpuacct, css);
}

static inline struct cpuacct *task_ca(struct task_struct *task)
{
	return container_of(task_subsys_state(task, cpuacct_subsys_id),
			    struct cpuacct, css);
}

#define INTERVAL (HZ * 10)

static inline u64 next_interval_boundary(u64 now)
{
	/* calculate the next interval boundary beyond the
	 * current time */
	do_div(now, INTERVAL);
	return (now + 1) * INTERVAL;
}

static struct cgroup_subsys_state *cpuacct_create(
	struct cgroup_subsys *ss, struct cgroup *cont)
{
	struct cpuacct *ca = kzalloc(sizeof(*ca), GFP_KERNEL);

	if (!ca)
		return ERR_PTR(-ENOMEM);
	spin_lock_init(&ca->lock);
	ca->next_interval_check = next_interval_boundary(get_jiffies_64());
	return &ca->css;
}

static void cpuacct_destroy(struct cgroup_subsys *ss,
			    struct cgroup *cont)
{
	kfree(cgroup_ca(cont));
}

/* Lazily update the load calculation if necessary. Called with ca locked */
static void cpuusage_update(struct cpuacct *ca)
{
	u64 now = get_jiffies_64();

	/* If we're not due for an update, return */
	if (ca->next_interval_check > now)
		return;

	if (ca->next_interval_check <= (now - INTERVAL)) {
		/* If it's been more than an interval since the last
		 * check, then catch up - the last interval must have
		 * been zero load */
		ca->last_interval_time = 0;
		ca->next_interval_check = next_interval_boundary(now);
	} else {
		/* If a steal takes the last interval time negative,
		 * then we just ignore it */
		if ((s64)ca->current_interval_time > 0)
			ca->last_interval_time = ca->current_interval_time;
		else
			ca->last_interval_time = 0;
		ca->next_interval_check += INTERVAL;
	}
	ca->current_interval_time = 0;
}

static u64 cpuusage_read(struct cgroup *cont, struct cftype *cft)
{
	struct cpuacct *ca = cgroup_ca(cont);
	u64 time;

	spin_lock_irq(&ca->lock);
	cpuusage_update(ca);
	time = cputime64_to_jiffies64(ca->time);
	spin_unlock_irq(&ca->lock);

	/* Convert 64-bit jiffies to seconds */
	time *= 1000;
	do_div(time, HZ);
	return time;
}

static u64 load_read(struct cgroup *cont, struct cftype *cft)
{
	struct cpuacct *ca = cgroup_ca(cont);
	u64 time;

	/* Find the time used in the previous interval */
	spin_lock_irq(&ca->lock);
	cpuusage_update(ca);
	time = cputime64_to_jiffies64(ca->last_interval_time);
	spin_unlock_irq(&ca->lock);

	/* Convert time to a percentage, to give the load in the
	 * previous period */
	time *= 100;
	do_div(time, INTERVAL);

	return time;
}

static struct cftype files[] = {
	{
		.name = "usage",
		.read_uint = cpuusage_read,
	},
	{
		.name = "load",
		.read_uint = load_read,
	}
};

static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cont)
{
	return cgroup_add_files(cont, ss, files, ARRAY_SIZE(files));
}

void cpuacct_charge(struct task_struct *task, cputime_t cputime)
{

	struct cpuacct *ca;
	unsigned long flags;

	if (!cpuacct_subsys.active)
		return;
	rcu_read_lock();
	ca = task_ca(task);
	if (ca) {
		spin_lock_irqsave(&ca->lock, flags);
		cpuusage_update(ca);
		ca->time = cputime64_add(ca->time, cputime);
		ca->current_interval_time =
			cputime64_add(ca->current_interval_time, cputime);
		spin_unlock_irqrestore(&ca->lock, flags);
	}
	rcu_read_unlock();
}

struct cgroup_subsys cpuacct_subsys = {
	.name = "cpuacct",
	.create = cpuacct_create,
	.destroy = cpuacct_destroy,
	.populate = cpuacct_populate,
	.subsys_id = cpuacct_subsys_id,
};
Commit	Line	Data
62d0df64 PM	1	/*
	2	* kernel/cpu_acct.c - CPU accounting cgroup subsystem
	3	*
	4	* Copyright (C) Google Inc, 2006
	5	*
	6	* Developed by Paul Menage (menage@google.com) and Balbir Singh
	7	* (balbir@in.ibm.com)
	8	*
	9	*/
	10
	11	/*
	12	* Example cgroup subsystem for reporting total CPU usage of tasks in a
	13	* cgroup, along with percentage load over a time interval
	14	*/
	15
	16	#include <linux/module.h>
	17	#include <linux/cgroup.h>
	18	#include <linux/fs.h>
	19	#include <linux/rcupdate.h>
	20
	21	#include <asm/div64.h>
	22
	23	struct cpuacct {
	24	struct cgroup_subsys_state css;
	25	spinlock_t lock;
	26	/* total time used by this class */
	27	cputime64_t time;
	28
	29	/* time when next load calculation occurs */
	30	u64 next_interval_check;
	31
	32	/* time used in current period */
	33	cputime64_t current_interval_time;
	34
	35	/* time used in last period */
	36	cputime64_t last_interval_time;
	37	};
	38
	39	struct cgroup_subsys cpuacct_subsys;
	40
	41	static inline struct cpuacct cgroup_ca(struct cgroup cont)
	42	{
	43	return container_of(cgroup_subsys_state(cont, cpuacct_subsys_id),
	44	struct cpuacct, css);
	45	}
	46
	47	static inline struct cpuacct task_ca(struct task_struct task)
	48	{
	49	return container_of(task_subsys_state(task, cpuacct_subsys_id),
	50	struct cpuacct, css);
	51	}
	52
	53	#define INTERVAL (HZ * 10)
	54
	55	static inline u64 next_interval_boundary(u64 now)
	56	{
	57	/* calculate the next interval boundary beyond the
	58	* current time */
	59	do_div(now, INTERVAL);
	60	return (now + 1) * INTERVAL;
	61	}
	62
	63	static struct cgroup_subsys_state *cpuacct_create(
	64	struct cgroup_subsys ss, struct cgroup cont)
65	{
66	struct cpuacct ca = kzalloc(sizeof(ca), GFP_KERNEL);
67
68	if (!ca)
69	return ERR_PTR(-ENOMEM);
70	spin_lock_init(&ca->lock);
71	ca->next_interval_check = next_interval_boundary(get_jiffies_64());
72	return &ca->css;
73	}
74
75	static void cpuacct_destroy(struct cgroup_subsys *ss,
76	struct cgroup *cont)
77	{
78	kfree(cgroup_ca(cont));
79	}
80
81	/* Lazily update the load calculation if necessary. Called with ca locked */
82	static void cpuusage_update(struct cpuacct *ca)
83	{
84	u64 now = get_jiffies_64();
85
86	/* If we're not due for an update, return */
87	if (ca->next_interval_check > now)
88	return;
89
90	if (ca->next_interval_check <= (now - INTERVAL)) {
91	/* If it's been more than an interval since the last
92	* check, then catch up - the last interval must have
93	* been zero load */
94	ca->last_interval_time = 0;
95	ca->next_interval_check = next_interval_boundary(now);
96	} else {
97	/* If a steal takes the last interval time negative,
98	* then we just ignore it */
99	if ((s64)ca->current_interval_time > 0)
100	ca->last_interval_time = ca->current_interval_time;
101	else
102	ca->last_interval_time = 0;
103	ca->next_interval_check += INTERVAL;
104	}
105	ca->current_interval_time = 0;
106	}
107
108	static u64 cpuusage_read(struct cgroup cont, struct cftype cft)
109	{
110	struct cpuacct *ca = cgroup_ca(cont);
111	u64 time;
112
113	spin_lock_irq(&ca->lock);
114	cpuusage_update(ca);
115	time = cputime64_to_jiffies64(ca->time);
116	spin_unlock_irq(&ca->lock);
117
118	/* Convert 64-bit jiffies to seconds */
119	time *= 1000;
120	do_div(time, HZ);
121	return time;
122	}
123
124	static u64 load_read(struct cgroup cont, struct cftype cft)
125	{
126	struct cpuacct *ca = cgroup_ca(cont);
127	u64 time;
128
129	/* Find the time used in the previous interval */
130	spin_lock_irq(&ca->lock);
131	cpuusage_update(ca);
132	time = cputime64_to_jiffies64(ca->last_interval_time);
133	spin_unlock_irq(&ca->lock);
134
135	/* Convert time to a percentage, to give the load in the
136	* previous period */
137	time *= 100;
138	do_div(time, INTERVAL);
139
140	return time;
141	}
142
143	static struct cftype files[] = {
144	{
145	.name = "usage",
146	.read_uint = cpuusage_read,
147	},
148	{
149	.name = "load",
150	.read_uint = load_read,
151	}
152	};
153
154	static int cpuacct_populate(struct cgroup_subsys ss, struct cgroup cont)
155	{
156	return cgroup_add_files(cont, ss, files, ARRAY_SIZE(files));
157	}
158
159	void cpuacct_charge(struct task_struct *task, cputime_t cputime)
160	{
161
162	struct cpuacct *ca;
163	unsigned long flags;
164
165	if (!cpuacct_subsys.active)
166	return;
167	rcu_read_lock();
168	ca = task_ca(task);
169	if (ca) {
170	spin_lock_irqsave(&ca->lock, flags);
171	cpuusage_update(ca);
172	ca->time = cputime64_add(ca->time, cputime);
173	ca->current_interval_time =
174	cputime64_add(ca->current_interval_time, cputime);
175	spin_unlock_irqrestore(&ca->lock, flags);
176	}
177	rcu_read_unlock();
178	}
179
180	struct cgroup_subsys cpuacct_subsys = {
181	.name = "cpuacct",
182	.create = cpuacct_create,
183	.destroy = cpuacct_destroy,
184	.populate = cpuacct_populate,
185	.subsys_id = cpuacct_subsys_id,
186	};