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

/*
 * cgroup_freezer.c -  control group freezer subsystem
 *
 * Copyright IBM Corporation, 2007
 *
 * Author : Cedric Le Goater <clg@fr.ibm.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2.1 of the GNU Lesser General Public License
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */

#include <linux/export.h>
#include <linux/slab.h>
#include <linux/cgroup.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/freezer.h>
#include <linux/seq_file.h>

enum freezer_state_flags {
	CGROUP_FREEZING_SELF	= (1 << 1), /* this freezer is freezing */
	CGROUP_FREEZING_PARENT	= (1 << 2), /* the parent freezer is freezing */
	CGROUP_FROZEN		= (1 << 3), /* this and its descendants frozen */

	/* mask for all FREEZING flags */
	CGROUP_FREEZING		= CGROUP_FREEZING_SELF | CGROUP_FREEZING_PARENT,
};

struct freezer {
	struct cgroup_subsys_state	css;
	unsigned int			state;
	spinlock_t			lock;
};

static inline struct freezer *cgroup_freezer(struct cgroup *cgroup)
{
	return container_of(cgroup_subsys_state(cgroup, freezer_subsys_id),
			    struct freezer, css);
}

static inline struct freezer *task_freezer(struct task_struct *task)
{
	return container_of(task_subsys_state(task, freezer_subsys_id),
			    struct freezer, css);
}

bool cgroup_freezing(struct task_struct *task)
{
	bool ret;

	rcu_read_lock();
	ret = task_freezer(task)->state & CGROUP_FREEZING;
	rcu_read_unlock();

	return ret;
}

/*
 * cgroups_write_string() limits the size of freezer state strings to
 * CGROUP_LOCAL_BUFFER_SIZE
 */
static const char *freezer_state_strs(unsigned int state)
{
	if (state & CGROUP_FROZEN)
		return "FROZEN";
	if (state & CGROUP_FREEZING)
		return "FREEZING";
	return "THAWED";
};

/*
 * State diagram
 * Transitions are caused by userspace writes to the freezer.state file.
 * The values in parenthesis are state labels. The rest are edge labels.
 *
 * (THAWED) --FROZEN--> (FREEZING) --FROZEN--> (FROZEN)
 *    ^ ^                    |                     |
 *    | \_______THAWED_______/                     |
 *    \__________________________THAWED____________/
 */

struct cgroup_subsys freezer_subsys;

static struct cgroup_subsys_state *freezer_create(struct cgroup *cgroup)
{
	struct freezer *freezer;

	freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
	if (!freezer)
		return ERR_PTR(-ENOMEM);

	spin_lock_init(&freezer->lock);
	return &freezer->css;
}

static void freezer_destroy(struct cgroup *cgroup)
{
	struct freezer *freezer = cgroup_freezer(cgroup);

	if (freezer->state & CGROUP_FREEZING)
		atomic_dec(&system_freezing_cnt);
	kfree(freezer);
}

/*
 * Tasks can be migrated into a different freezer anytime regardless of its
 * current state.  freezer_attach() is responsible for making new tasks
 * conform to the current state.
 *
 * Freezer state changes and task migration are synchronized via
 * @freezer->lock.  freezer_attach() makes the new tasks conform to the
 * current state and all following state changes can see the new tasks.
 */
static void freezer_attach(struct cgroup *new_cgrp, struct cgroup_taskset *tset)
{
	struct freezer *freezer = cgroup_freezer(new_cgrp);
	struct task_struct *task;

	spin_lock_irq(&freezer->lock);

	/*
	 * Make the new tasks conform to the current state of @new_cgrp.
	 * For simplicity, when migrating any task to a FROZEN cgroup, we
	 * revert it to FREEZING and let update_if_frozen() determine the
	 * correct state later.
	 *
	 * Tasks in @tset are on @new_cgrp but may not conform to its
	 * current state before executing the following - !frozen tasks may
	 * be visible in a FROZEN cgroup and frozen tasks in a THAWED one.
	 */
	cgroup_taskset_for_each(task, new_cgrp, tset) {
		if (!(freezer->state & CGROUP_FREEZING)) {
			__thaw_task(task);
		} else {
			freeze_task(task);
			freezer->state &= ~CGROUP_FROZEN;
		}
	}

	spin_unlock_irq(&freezer->lock);
}

static void freezer_fork(struct task_struct *task)
{
	struct freezer *freezer;

	rcu_read_lock();
	freezer = task_freezer(task);

	/*
	 * The root cgroup is non-freezable, so we can skip the
	 * following check.
	 */
	if (!freezer->css.cgroup->parent)
		goto out;

	spin_lock_irq(&freezer->lock);
	if (freezer->state & CGROUP_FREEZING)
		freeze_task(task);
	spin_unlock_irq(&freezer->lock);
out:
	rcu_read_unlock();
}

/*
 * We change from FREEZING to FROZEN lazily if the cgroup was only
 * partially frozen when we exitted write.  Caller must hold freezer->lock.
 *
 * Task states and freezer state might disagree while tasks are being
 * migrated into or out of @cgroup, so we can't verify task states against
 * @freezer state here.  See freezer_attach() for details.
 */
static void update_if_frozen(struct freezer *freezer)
{
	struct cgroup *cgroup = freezer->css.cgroup;
	struct cgroup_iter it;
	struct task_struct *task;

	if (!(freezer->state & CGROUP_FREEZING) ||
	    (freezer->state & CGROUP_FROZEN))
		return;

	cgroup_iter_start(cgroup, &it);

	while ((task = cgroup_iter_next(cgroup, &it))) {
		if (freezing(task)) {
			/*
			 * freezer_should_skip() indicates that the task
			 * should be skipped when determining freezing
			 * completion.  Consider it frozen in addition to
			 * the usual frozen condition.
			 */
			if (!frozen(task) && !freezer_should_skip(task))
				goto notyet;
		}
	}

	freezer->state |= CGROUP_FROZEN;
notyet:
	cgroup_iter_end(cgroup, &it);
}

static int freezer_read(struct cgroup *cgroup, struct cftype *cft,
			struct seq_file *m)
{
	struct freezer *freezer = cgroup_freezer(cgroup);
	unsigned int state;

	spin_lock_irq(&freezer->lock);
	update_if_frozen(freezer);
	state = freezer->state;
	spin_unlock_irq(&freezer->lock);

	seq_puts(m, freezer_state_strs(state));
	seq_putc(m, '\n');
	return 0;
}

static void freeze_cgroup(struct freezer *freezer)
{
	struct cgroup *cgroup = freezer->css.cgroup;
	struct cgroup_iter it;
	struct task_struct *task;

	cgroup_iter_start(cgroup, &it);
	while ((task = cgroup_iter_next(cgroup, &it)))
		freeze_task(task);
	cgroup_iter_end(cgroup, &it);
}

static void unfreeze_cgroup(struct freezer *freezer)
{
	struct cgroup *cgroup = freezer->css.cgroup;
	struct cgroup_iter it;
	struct task_struct *task;

	cgroup_iter_start(cgroup, &it);
	while ((task = cgroup_iter_next(cgroup, &it)))
		__thaw_task(task);
	cgroup_iter_end(cgroup, &it);
}

/**
 * freezer_apply_state - apply state change to a single cgroup_freezer
 * @freezer: freezer to apply state change to
 * @freeze: whether to freeze or unfreeze
 * @state: CGROUP_FREEZING_* flag to set or clear
 *
 * Set or clear @state on @cgroup according to @freeze, and perform
 * freezing or thawing as necessary.
 */
static void freezer_apply_state(struct freezer *freezer, bool freeze,
				unsigned int state)
{
	/* also synchronizes against task migration, see freezer_attach() */
	lockdep_assert_held(&freezer->lock);

	if (freeze) {
		if (!(freezer->state & CGROUP_FREEZING))
			atomic_inc(&system_freezing_cnt);
		freezer->state |= state;
		freeze_cgroup(freezer);
	} else {
		bool was_freezing = freezer->state & CGROUP_FREEZING;

		freezer->state &= ~state;

		if (!(freezer->state & CGROUP_FREEZING)) {
			if (was_freezing)
				atomic_dec(&system_freezing_cnt);
			freezer->state &= ~CGROUP_FROZEN;
			unfreeze_cgroup(freezer);
		}
	}
}

/**
 * freezer_change_state - change the freezing state of a cgroup_freezer
 * @freezer: freezer of interest
 * @freeze: whether to freeze or thaw
 *
 * Freeze or thaw @cgroup according to @freeze.
 */
static void freezer_change_state(struct freezer *freezer, bool freeze)
{
	/* update @freezer */
	spin_lock_irq(&freezer->lock);
	freezer_apply_state(freezer, freeze, CGROUP_FREEZING_SELF);
	spin_unlock_irq(&freezer->lock);
}

static int freezer_write(struct cgroup *cgroup, struct cftype *cft,
			 const char *buffer)
{
	bool freeze;

	if (strcmp(buffer, freezer_state_strs(0)) == 0)
		freeze = false;
	else if (strcmp(buffer, freezer_state_strs(CGROUP_FROZEN)) == 0)
		freeze = true;
	else
		return -EINVAL;

	freezer_change_state(cgroup_freezer(cgroup), freeze);
	return 0;
}

static u64 freezer_self_freezing_read(struct cgroup *cgroup, struct cftype *cft)
{
	struct freezer *freezer = cgroup_freezer(cgroup);

	return (bool)(freezer->state & CGROUP_FREEZING_SELF);
}

static u64 freezer_parent_freezing_read(struct cgroup *cgroup, struct cftype *cft)
{
	struct freezer *freezer = cgroup_freezer(cgroup);

	return (bool)(freezer->state & CGROUP_FREEZING_PARENT);
}

static struct cftype files[] = {
	{
		.name = "state",
		.flags = CFTYPE_NOT_ON_ROOT,
		.read_seq_string = freezer_read,
		.write_string = freezer_write,
	},
	{
		.name = "self_freezing",
		.flags = CFTYPE_NOT_ON_ROOT,
		.read_u64 = freezer_self_freezing_read,
	},
	{
		.name = "parent_freezing",
		.flags = CFTYPE_NOT_ON_ROOT,
		.read_u64 = freezer_parent_freezing_read,
	},
	{ }	/* terminate */
};

struct cgroup_subsys freezer_subsys = {
	.name		= "freezer",
	.create		= freezer_create,
	.destroy	= freezer_destroy,
	.subsys_id	= freezer_subsys_id,
	.attach		= freezer_attach,
	.fork		= freezer_fork,
	.base_cftypes	= files,

	/*
	 * freezer subsys doesn't handle hierarchy at all.  Frozen state
	 * should be inherited through the hierarchy - if a parent is
	 * frozen, all its children should be frozen.  Fix it and remove
	 * the following.
	 */
	.broken_hierarchy = true,
};
Commit	Line	Data
	1	/*
	2	* cgroup_freezer.c - control group freezer subsystem
	3	*
	4	* Copyright IBM Corporation, 2007
	5	*
	6	* Author : Cedric Le Goater <clg@fr.ibm.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of version 2.1 of the GNU Lesser General Public License
	10	* as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it would be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	15	*/
	16
	17	#include <linux/export.h>
	18	#include <linux/slab.h>
	19	#include <linux/cgroup.h>
	20	#include <linux/fs.h>
	21	#include <linux/uaccess.h>
	22	#include <linux/freezer.h>
	23	#include <linux/seq_file.h>
	24
	25	enum freezer_state_flags {
	26	CGROUP_FREEZING_SELF = (1 << 1), /* this freezer is freezing */
	27	CGROUP_FREEZING_PARENT = (1 << 2), /* the parent freezer is freezing */
	28	CGROUP_FROZEN = (1 << 3), /* this and its descendants frozen */
	29
	30	/* mask for all FREEZING flags */
	31	CGROUP_FREEZING = CGROUP_FREEZING_SELF \| CGROUP_FREEZING_PARENT,
	32	};
	33
	34	struct freezer {
	35	struct cgroup_subsys_state css;
	36	unsigned int state;
	37	spinlock_t lock;
	38	};
	39
	40	static inline struct freezer cgroup_freezer(struct cgroup cgroup)
	41	{
	42	return container_of(cgroup_subsys_state(cgroup, freezer_subsys_id),
	43	struct freezer, css);
	44	}
	45
	46	static inline struct freezer task_freezer(struct task_struct task)
	47	{
	48	return container_of(task_subsys_state(task, freezer_subsys_id),
	49	struct freezer, css);
	50	}
	51
	52	bool cgroup_freezing(struct task_struct *task)
	53	{
	54	bool ret;
	55
	56	rcu_read_lock();
	57	ret = task_freezer(task)->state & CGROUP_FREEZING;
	58	rcu_read_unlock();
	59
	60	return ret;
	61	}
	62
	63	/*
	64	* cgroups_write_string() limits the size of freezer state strings to
	65	* CGROUP_LOCAL_BUFFER_SIZE
	66	*/
	67	static const char *freezer_state_strs(unsigned int state)
	68	{
	69	if (state & CGROUP_FROZEN)
	70	return "FROZEN";
	71	if (state & CGROUP_FREEZING)
	72	return "FREEZING";
	73	return "THAWED";
	74	};
	75
	76	/*
	77	* State diagram
	78	* Transitions are caused by userspace writes to the freezer.state file.
	79	* The values in parenthesis are state labels. The rest are edge labels.
	80	*
	81	* (THAWED) --FROZEN--> (FREEZING) --FROZEN--> (FROZEN)
	82	* ^ ^ \| \|
	83	* \| \_______THAWED_______/ \|
	84	* \__________________________THAWED____________/
	85	*/
	86
	87	struct cgroup_subsys freezer_subsys;
	88
	89	static struct cgroup_subsys_state freezer_create(struct cgroup cgroup)
	90	{
	91	struct freezer *freezer;
	92
	93	freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
	94	if (!freezer)
	95	return ERR_PTR(-ENOMEM);
	96
	97	spin_lock_init(&freezer->lock);
	98	return &freezer->css;
	99	}
	100
	101	static void freezer_destroy(struct cgroup *cgroup)
	102	{
	103	struct freezer *freezer = cgroup_freezer(cgroup);
	104
	105	if (freezer->state & CGROUP_FREEZING)
	106	atomic_dec(&system_freezing_cnt);
	107	kfree(freezer);
	108	}
	109
	110	/*
	111	* Tasks can be migrated into a different freezer anytime regardless of its
	112	* current state. freezer_attach() is responsible for making new tasks
	113	* conform to the current state.
	114	*
	115	* Freezer state changes and task migration are synchronized via
	116	* @freezer->lock. freezer_attach() makes the new tasks conform to the
	117	* current state and all following state changes can see the new tasks.
	118	*/
	119	static void freezer_attach(struct cgroup new_cgrp, struct cgroup_taskset tset)
	120	{
	121	struct freezer *freezer = cgroup_freezer(new_cgrp);
	122	struct task_struct *task;
	123
	124	spin_lock_irq(&freezer->lock);
	125
	126	/*
	127	* Make the new tasks conform to the current state of @new_cgrp.
	128	* For simplicity, when migrating any task to a FROZEN cgroup, we
	129	* revert it to FREEZING and let update_if_frozen() determine the
	130	* correct state later.
	131	*
	132	* Tasks in @tset are on @new_cgrp but may not conform to its
	133	* current state before executing the following - !frozen tasks may
	134	* be visible in a FROZEN cgroup and frozen tasks in a THAWED one.
	135	*/
	136	cgroup_taskset_for_each(task, new_cgrp, tset) {
	137	if (!(freezer->state & CGROUP_FREEZING)) {
	138	__thaw_task(task);
	139	} else {
	140	freeze_task(task);
	141	freezer->state &= ~CGROUP_FROZEN;
	142	}
	143	}
	144
	145	spin_unlock_irq(&freezer->lock);
	146	}
	147
	148	static void freezer_fork(struct task_struct *task)
	149	{
	150	struct freezer *freezer;
	151
	152	rcu_read_lock();
	153	freezer = task_freezer(task);
	154
	155	/*
	156	* The root cgroup is non-freezable, so we can skip the
	157	* following check.
	158	*/
	159	if (!freezer->css.cgroup->parent)
	160	goto out;
	161
	162	spin_lock_irq(&freezer->lock);
	163	if (freezer->state & CGROUP_FREEZING)
	164	freeze_task(task);
	165	spin_unlock_irq(&freezer->lock);
	166	out:
	167	rcu_read_unlock();
	168	}
	169
	170	/*
	171	* We change from FREEZING to FROZEN lazily if the cgroup was only
	172	* partially frozen when we exitted write. Caller must hold freezer->lock.
	173	*
	174	* Task states and freezer state might disagree while tasks are being
	175	* migrated into or out of @cgroup, so we can't verify task states against
	176	* @freezer state here. See freezer_attach() for details.
	177	*/
	178	static void update_if_frozen(struct freezer *freezer)
	179	{
	180	struct cgroup *cgroup = freezer->css.cgroup;
	181	struct cgroup_iter it;
	182	struct task_struct *task;
	183
	184	if (!(freezer->state & CGROUP_FREEZING) \|\|
	185	(freezer->state & CGROUP_FROZEN))
	186	return;
	187
	188	cgroup_iter_start(cgroup, &it);
	189
	190	while ((task = cgroup_iter_next(cgroup, &it))) {
	191	if (freezing(task)) {
	192	/*
	193	* freezer_should_skip() indicates that the task
	194	* should be skipped when determining freezing
	195	* completion. Consider it frozen in addition to
	196	* the usual frozen condition.
	197	*/
	198	if (!frozen(task) && !freezer_should_skip(task))
	199	goto notyet;
	200	}
	201	}
	202
	203	freezer->state \|= CGROUP_FROZEN;
	204	notyet:
	205	cgroup_iter_end(cgroup, &it);
	206	}
	207
	208	static int freezer_read(struct cgroup cgroup, struct cftype cft,
	209	struct seq_file *m)
	210	{
	211	struct freezer *freezer = cgroup_freezer(cgroup);
	212	unsigned int state;
	213
	214	spin_lock_irq(&freezer->lock);
	215	update_if_frozen(freezer);
	216	state = freezer->state;
	217	spin_unlock_irq(&freezer->lock);
	218
	219	seq_puts(m, freezer_state_strs(state));
	220	seq_putc(m, '\n');
	221	return 0;
	222	}
	223
	224	static void freeze_cgroup(struct freezer *freezer)
	225	{
	226	struct cgroup *cgroup = freezer->css.cgroup;
	227	struct cgroup_iter it;
	228	struct task_struct *task;
	229
	230	cgroup_iter_start(cgroup, &it);
	231	while ((task = cgroup_iter_next(cgroup, &it)))
	232	freeze_task(task);
	233	cgroup_iter_end(cgroup, &it);
	234	}
	235
	236	static void unfreeze_cgroup(struct freezer *freezer)
	237	{
	238	struct cgroup *cgroup = freezer->css.cgroup;
	239	struct cgroup_iter it;
	240	struct task_struct *task;
	241
	242	cgroup_iter_start(cgroup, &it);
	243	while ((task = cgroup_iter_next(cgroup, &it)))
	244	__thaw_task(task);
	245	cgroup_iter_end(cgroup, &it);
	246	}
	247
	248	/**
	249	* freezer_apply_state - apply state change to a single cgroup_freezer
	250	* @freezer: freezer to apply state change to
	251	* @freeze: whether to freeze or unfreeze
	252	* @state: CGROUP_FREEZING_* flag to set or clear
	253	*
	254	* Set or clear @state on @cgroup according to @freeze, and perform
	255	* freezing or thawing as necessary.
	256	*/
	257	static void freezer_apply_state(struct freezer *freezer, bool freeze,
	258	unsigned int state)
	259	{
	260	/* also synchronizes against task migration, see freezer_attach() */
	261	lockdep_assert_held(&freezer->lock);
	262
	263	if (freeze) {
	264	if (!(freezer->state & CGROUP_FREEZING))
	265	atomic_inc(&system_freezing_cnt);
	266	freezer->state \|= state;
	267	freeze_cgroup(freezer);
	268	} else {
	269	bool was_freezing = freezer->state & CGROUP_FREEZING;
	270
	271	freezer->state &= ~state;
	272
	273	if (!(freezer->state & CGROUP_FREEZING)) {
	274	if (was_freezing)
	275	atomic_dec(&system_freezing_cnt);
	276	freezer->state &= ~CGROUP_FROZEN;
	277	unfreeze_cgroup(freezer);
	278	}
	279	}
	280	}
	281
	282	/**
	283	* freezer_change_state - change the freezing state of a cgroup_freezer
	284	* @freezer: freezer of interest
	285	* @freeze: whether to freeze or thaw
	286	*
	287	* Freeze or thaw @cgroup according to @freeze.
	288	*/
	289	static void freezer_change_state(struct freezer *freezer, bool freeze)
	290	{
	291	/* update @freezer */
	292	spin_lock_irq(&freezer->lock);
	293	freezer_apply_state(freezer, freeze, CGROUP_FREEZING_SELF);
	294	spin_unlock_irq(&freezer->lock);
	295	}
	296
	297	static int freezer_write(struct cgroup cgroup, struct cftype cft,
	298	const char *buffer)
	299	{
	300	bool freeze;
	301
	302	if (strcmp(buffer, freezer_state_strs(0)) == 0)
	303	freeze = false;
	304	else if (strcmp(buffer, freezer_state_strs(CGROUP_FROZEN)) == 0)
	305	freeze = true;
	306	else
	307	return -EINVAL;
	308
	309	freezer_change_state(cgroup_freezer(cgroup), freeze);
	310	return 0;
	311	}
	312
	313	static u64 freezer_self_freezing_read(struct cgroup cgroup, struct cftype cft)
	314	{
	315	struct freezer *freezer = cgroup_freezer(cgroup);
	316
	317	return (bool)(freezer->state & CGROUP_FREEZING_SELF);
	318	}
	319
	320	static u64 freezer_parent_freezing_read(struct cgroup cgroup, struct cftype cft)
	321	{
	322	struct freezer *freezer = cgroup_freezer(cgroup);
	323
	324	return (bool)(freezer->state & CGROUP_FREEZING_PARENT);
	325	}
	326
	327	static struct cftype files[] = {
	328	{
	329	.name = "state",
	330	.flags = CFTYPE_NOT_ON_ROOT,
	331	.read_seq_string = freezer_read,
	332	.write_string = freezer_write,
	333	},
	334	{
	335	.name = "self_freezing",
	336	.flags = CFTYPE_NOT_ON_ROOT,
	337	.read_u64 = freezer_self_freezing_read,
	338	},
	339	{
	340	.name = "parent_freezing",
	341	.flags = CFTYPE_NOT_ON_ROOT,
	342	.read_u64 = freezer_parent_freezing_read,
	343	},
	344	{ } /* terminate */
	345	};
	346
	347	struct cgroup_subsys freezer_subsys = {
	348	.name = "freezer",
	349	.create = freezer_create,
	350	.destroy = freezer_destroy,
	351	.subsys_id = freezer_subsys_id,
	352	.attach = freezer_attach,
	353	.fork = freezer_fork,
	354	.base_cftypes = files,
	355
	356	/*
	357	* freezer subsys doesn't handle hierarchy at all. Frozen state
	358	* should be inherited through the hierarchy - if a parent is
	359	* frozen, all its children should be frozen. Fix it and remove
	360	* the following.
	361	*/
	362	.broken_hierarchy = true,
	363	};