revert "Task Control Groups: example CPU accounting subsystem"

Revert 62d0df64065e7c135d0002f069444fbdfc64768f. This was originally intended as a simple initial example of how to create a control groups subsystem; it wasn't intended for mainline, but I didn't make this clear enough to Andrew. The CFS cgroup subsystem now has better functionality for the per-cgroup usage accounting (based directly on CFS stats) than the "usage" status file in this patch, and the "load" status file is rather simplistic - although having a per-cgroup load average report would be a useful feature, I don't believe this patch actually provides it. If it gets into the final 2.6.24 we'd probably have to support this interface for ever. Cc: Paul Menage <menage@google.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

revert "Task Control Groups: example CPU accounting subsystem"
Revert 62d0df64065e7c135d0002f069444fbdfc64768f. This was originally intended as a simple initial example of how to create a control groups subsystem; it wasn't intended for mainline, but I didn't make this clear enough to Andrew. The CFS cgroup subsystem now has better functionality for the per-cgroup usage accounting (based directly on CFS stats) than the "usage" status file in this patch, and the "load" status file is rather simplistic - although having a per-cgroup load average report would be a useful feature, I don't believe this patch actually provides it. If it gets into the final 2.6.24 we'd probably have to support this interface for ever. Cc: Paul Menage <menage@google.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Andrew Morton · Linus Torvalds
1 parent 45c682a68a
Showing 6 changed files with 3 additions and 225 deletions Side-by-side Diff
include/linux/cgroup_subsys.h
include/linux/cpu_acct.h
init/Kconfig
kernel/Makefile
kernel/cpu_acct.c
kernel/sched.c
@@ -13,12 +13,6 @@
  
 /* */
  
-#ifdef CONFIG_CGROUP_CPUACCT
-SUBSYS(cpuacct)
-#endif
-
-/* */
-
 #ifdef CONFIG_CGROUP_DEBUG
 SUBSYS(debug)
 #endif
-
-#ifndef _LINUX_CPU_ACCT_H
-#define _LINUX_CPU_ACCT_H
-
-#include <linux/cgroup.h>
-#include <asm/cputime.h>
-
-#ifdef CONFIG_CGROUP_CPUACCT
-extern void cpuacct_charge(struct task_struct *, cputime_t cputime);
-#else
-static void inline cpuacct_charge(struct task_struct *p, cputime_t cputime) {}
-#endif
-
-#endif
@@ -301,13 +301,6 @@
           for instance virtual servers and checkpoint/restart
           jobs.
  
-config CGROUP_CPUACCT
-	bool "Simple CPU accounting cgroup subsystem"
-	depends on CGROUPS
-	help
-	  Provides a simple Resource Controller for monitoring the
-	  total CPU consumed by the tasks in a cgroup
-
 config CPUSETS
 	bool "Cpuset support"
 	depends on SMP && CGROUPS
@@ -40,7 +40,6 @@
 obj-$(CONFIG_CGROUPS) += cgroup.o
 obj-$(CONFIG_CGROUP_DEBUG) += cgroup_debug.o
 obj-$(CONFIG_CPUSETS) += cpuset.o
-obj-$(CONFIG_CGROUP_CPUACCT) += cpu_acct.o
 obj-$(CONFIG_CGROUP_NS) += ns_cgroup.o
 obj-$(CONFIG_IKCONFIG) += configs.o
 obj-$(CONFIG_STOP_MACHINE) += stop_machine.o
-/*
- * 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,
-};
@@ -52,7 +52,6 @@
 #include <linux/cpu.h>
 #include <linux/cpuset.h>
 #include <linux/percpu.h>
-#include <linux/cpu_acct.h>
 #include <linux/kthread.h>
 #include <linux/seq_file.h>
 #include <linux/sysctl.h>
  
@@ -3338,13 +3337,9 @@
 {
 	struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
 	cputime64_t tmp;
-	struct rq *rq = this_rq();
  
 	p->utime = cputime_add(p->utime, cputime);
  
-	if (p != rq->idle)
-		cpuacct_charge(p, cputime);
-
 	/* Add user time to cpustat. */
 	tmp = cputime_to_cputime64(cputime);
 	if (TASK_NICE(p) > 0)
  
@@ -3408,10 +3403,9 @@
 		cpustat->irq = cputime64_add(cpustat->irq, tmp);
 	else if (softirq_count())
 		cpustat->softirq = cputime64_add(cpustat->softirq, tmp);
-	else if (p != rq->idle) {
+	else if (p != rq->idle)
 		cpustat->system = cputime64_add(cpustat->system, tmp);
-		cpuacct_charge(p, cputime);
-	} else if (atomic_read(&rq->nr_iowait) > 0)
+	else if (atomic_read(&rq->nr_iowait) > 0)
 		cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
 	else
 		cpustat->idle = cputime64_add(cpustat->idle, tmp);
  
@@ -3447,10 +3441,8 @@
 			cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
 		else
 			cpustat->idle = cputime64_add(cpustat->idle, tmp);
-	} else {
+	} else
 		cpustat->steal = cputime64_add(cpustat->steal, tmp);
-		cpuacct_charge(p, -tmp);
-	}
 }
  
 /*
...	...	@@ -13,12 +13,6 @@
13	13
14	14	/* */
15	15
16		-#ifdef CONFIG_CGROUP_CPUACCT
17		-SUBSYS(cpuacct)
18		-#endif
19		-
20		-/* */
21		-
22	16	#ifdef CONFIG_CGROUP_DEBUG
23	17	SUBSYS(debug)
24	18	#endif
1		-
2		-#ifndef _LINUX_CPU_ACCT_H
3		-#define _LINUX_CPU_ACCT_H
4		-
5		-#include <linux/cgroup.h>
6		-#include <asm/cputime.h>
7		-
8		-#ifdef CONFIG_CGROUP_CPUACCT
9		-extern void cpuacct_charge(struct task_struct *, cputime_t cputime);
10		-#else
11		-static void inline cpuacct_charge(struct task_struct *p, cputime_t cputime) {}
12		-#endif
13		-
14		-#endif
...	...	@@ -301,13 +301,6 @@
301	301	for instance virtual servers and checkpoint/restart
302	302	jobs.
303	303
304		-config CGROUP_CPUACCT
305		- bool "Simple CPU accounting cgroup subsystem"
306		- depends on CGROUPS
307		- help
308		- Provides a simple Resource Controller for monitoring the
309		- total CPU consumed by the tasks in a cgroup
310		-
311	304	config CPUSETS
312	305	bool "Cpuset support"
313	306	depends on SMP && CGROUPS
...	...	@@ -40,7 +40,6 @@
40	40	obj-$(CONFIG_CGROUPS) += cgroup.o
41	41	obj-$(CONFIG_CGROUP_DEBUG) += cgroup_debug.o
42	42	obj-$(CONFIG_CPUSETS) += cpuset.o
43		-obj-$(CONFIG_CGROUP_CPUACCT) += cpu_acct.o
44	43	obj-$(CONFIG_CGROUP_NS) += ns_cgroup.o
45	44	obj-$(CONFIG_IKCONFIG) += configs.o
46	45	obj-$(CONFIG_STOP_MACHINE) += stop_machine.o
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		-};
...	...	@@ -52,7 +52,6 @@
52	52	#include <linux/cpu.h>
53	53	#include <linux/cpuset.h>
54	54	#include <linux/percpu.h>
55		-#include <linux/cpu_acct.h>
56	55	#include <linux/kthread.h>
57	56	#include <linux/seq_file.h>
58	57	#include <linux/sysctl.h>
59	58
...	...	@@ -3338,13 +3337,9 @@
3338	3337	{
3339	3338	struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
3340	3339	cputime64_t tmp;
3341		- struct rq *rq = this_rq();
3342	3340
3343	3341	p->utime = cputime_add(p->utime, cputime);
3344	3342
3345		- if (p != rq->idle)
3346		- cpuacct_charge(p, cputime);
3347		-
3348	3343	/* Add user time to cpustat. */
3349	3344	tmp = cputime_to_cputime64(cputime);
3350	3345	if (TASK_NICE(p) > 0)
3351	3346
...	...	@@ -3408,10 +3403,9 @@
3408	3403	cpustat->irq = cputime64_add(cpustat->irq, tmp);
3409	3404	else if (softirq_count())
3410	3405	cpustat->softirq = cputime64_add(cpustat->softirq, tmp);
3411		- else if (p != rq->idle) {
	3406	+ else if (p != rq->idle)
3412	3407	cpustat->system = cputime64_add(cpustat->system, tmp);
3413		- cpuacct_charge(p, cputime);
3414		- } else if (atomic_read(&rq->nr_iowait) > 0)
	3408	+ else if (atomic_read(&rq->nr_iowait) > 0)
3415	3409	cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
3416	3410	else
3417	3411	cpustat->idle = cputime64_add(cpustat->idle, tmp);
3418	3412
...	...	@@ -3447,10 +3441,8 @@
3447	3441	cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
3448	3442	else
3449	3443	cpustat->idle = cputime64_add(cpustat->idle, tmp);
3450		- } else {
	3444	+ } else
3451	3445	cpustat->steal = cputime64_add(cpustat->steal, tmp);
3452		- cpuacct_charge(p, -tmp);
3453		- }
3454	3446	}
3455	3447
3456	3448	/*