[deliverable/linux.git] / include / linux / freezer.h

/* Freezer declarations */

#include <linux/sched.h>

#ifdef CONFIG_PM
/*
 * Check if a process has been frozen
 */
static inline int frozen(struct task_struct *p)
{
	return p->flags & PF_FROZEN;
}

/*
 * Check if there is a request to freeze a process
 */
static inline int freezing(struct task_struct *p)
{
	return test_tsk_thread_flag(p, TIF_FREEZE);
}

/*
 * Request that a process be frozen
 */
static inline void freeze(struct task_struct *p)
{
	set_tsk_thread_flag(p, TIF_FREEZE);
}

/*
 * Sometimes we may need to cancel the previous 'freeze' request
 */
static inline void do_not_freeze(struct task_struct *p)
{
	clear_tsk_thread_flag(p, TIF_FREEZE);
}

/*
 * Wake up a frozen process
 *
 * task_lock() is taken to prevent the race with refrigerator() which may
 * occur if the freezing of tasks fails.  Namely, without the lock, if the
 * freezing of tasks failed, thaw_tasks() might have run before a task in
 * refrigerator() could call frozen_process(), in which case the task would be
 * frozen and no one would thaw it.
 */
static inline int thaw_process(struct task_struct *p)
{
	task_lock(p);
	if (frozen(p)) {
		p->flags &= ~PF_FROZEN;
		task_unlock(p);
		wake_up_process(p);
		return 1;
	}
	clear_tsk_thread_flag(p, TIF_FREEZE);
	task_unlock(p);
	return 0;
}

extern void refrigerator(void);
extern int freeze_processes(void);
extern void thaw_processes(void);

static inline int try_to_freeze(void)
{
	if (freezing(current)) {
		refrigerator();
		return 1;
	} else
		return 0;
}

/*
 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
 * calls wait_for_completion(&vfork) and reset right after it returns from this
 * function.  Next, the parent should call try_to_freeze() to freeze itself
 * appropriately in case the child has exited before the freezing of tasks is
 * complete.  However, we don't want kernel threads to be frozen in unexpected
 * places, so we allow them to block freeze_processes() instead or to set
 * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
 * parents.  Fortunately, in the ____call_usermodehelper() case the parent won't
 * really block freeze_processes(), since ____call_usermodehelper() (the child)
 * does a little before exec/exit and it can't be frozen before waking up the
 * parent.
 */

/*
 * If the current task is a user space one, tell the freezer not to count it as
 * freezable.
 */
static inline void freezer_do_not_count(void)
{
	if (current->mm)
		current->flags |= PF_FREEZER_SKIP;
}

/*
 * If the current task is a user space one, tell the freezer to count it as
 * freezable again and try to freeze it.
 */
static inline void freezer_count(void)
{
	if (current->mm) {
		current->flags &= ~PF_FREEZER_SKIP;
		try_to_freeze();
	}
}

/*
 * Check if the task should be counted as freezeable by the freezer
 */
static inline int freezer_should_skip(struct task_struct *p)
{
	return !!(p->flags & PF_FREEZER_SKIP);
}

#else
static inline int frozen(struct task_struct *p) { return 0; }
static inline int freezing(struct task_struct *p) { return 0; }
static inline void freeze(struct task_struct *p) { BUG(); }
static inline int thaw_process(struct task_struct *p) { return 1; }

static inline void refrigerator(void) {}
static inline int freeze_processes(void) { BUG(); return 0; }
static inline void thaw_processes(void) {}

static inline int try_to_freeze(void) { return 0; }

static inline void freezer_do_not_count(void) {}
static inline void freezer_count(void) {}
static inline int freezer_should_skip(struct task_struct *p) { return 0; }
#endif
Commit	Line	Data
7dfb7103 NC	1	/* Freezer declarations */
7dfb7103 NC	2
5c543eff RD	3	#include <linux/sched.h>
5c543eff RD	4
7dfb7103 NC	5	#ifdef CONFIG_PM
	6	/*
	7	* Check if a process has been frozen
	8	*/
	9	static inline int frozen(struct task_struct *p)
	10	{
	11	return p->flags & PF_FROZEN;
	12	}
	13
	14	/*
	15	* Check if there is a request to freeze a process
	16	*/
	17	static inline int freezing(struct task_struct *p)
	18	{
8a102eed	19	return test_tsk_thread_flag(p, TIF_FREEZE);
7dfb7103 NC	20	}
	21
	22	/*
	23	* Request that a process be frozen
7dfb7103 NC	24	*/
	25	static inline void freeze(struct task_struct *p)
	26	{
8a102eed	27	set_tsk_thread_flag(p, TIF_FREEZE);
7dfb7103 NC	28	}
	29
	30	/*
	31	* Sometimes we may need to cancel the previous 'freeze' request
	32	*/
	33	static inline void do_not_freeze(struct task_struct *p)
	34	{
8a102eed	35	clear_tsk_thread_flag(p, TIF_FREEZE);
7dfb7103 NC	36	}
	37
	38	/*
	39	* Wake up a frozen process
33e1c288 RW	40	*
	41	* task_lock() is taken to prevent the race with refrigerator() which may
	42	* occur if the freezing of tasks fails. Namely, without the lock, if the
	43	* freezing of tasks failed, thaw_tasks() might have run before a task in
	44	* refrigerator() could call frozen_process(), in which case the task would be
	45	* frozen and no one would thaw it.
7dfb7103 NC	46	*/
	47	static inline int thaw_process(struct task_struct *p)
	48	{
33e1c288	49	task_lock(p);
7dfb7103 NC	50	if (frozen(p)) {
7dfb7103 NC	51	p->flags &= ~PF_FROZEN;
33e1c288	52	task_unlock(p);
7dfb7103 NC	53	wake_up_process(p);
	54	return 1;
	55	}
33e1c288 RW	56	clear_tsk_thread_flag(p, TIF_FREEZE);
33e1c288 RW	57	task_unlock(p);
7dfb7103 NC	58	return 0;
	59	}
	60
7dfb7103 NC	61	extern void refrigerator(void);
7dfb7103 NC	62	extern int freeze_processes(void);
a9b6f562	63	extern void thaw_processes(void);
7dfb7103 NC	64
	65	static inline int try_to_freeze(void)
	66	{
	67	if (freezing(current)) {
	68	refrigerator();
	69	return 1;
	70	} else
	71	return 0;
	72	}
ff39593a	73
ba96a0c8 RW	74	/*
	75	* The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
	76	* calls wait_for_completion(&vfork) and reset right after it returns from this
	77	* function. Next, the parent should call try_to_freeze() to freeze itself
	78	* appropriately in case the child has exited before the freezing of tasks is
	79	* complete. However, we don't want kernel threads to be frozen in unexpected
	80	* places, so we allow them to block freeze_processes() instead or to set
	81	* PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
	82	* parents. Fortunately, in the ____call_usermodehelper() case the parent won't
	83	* really block freeze_processes(), since ____call_usermodehelper() (the child)
	84	* does a little before exec/exit and it can't be frozen before waking up the
	85	* parent.
	86	*/
	87
	88	/*
	89	* If the current task is a user space one, tell the freezer not to count it as
	90	* freezable.
	91	*/
	92	static inline void freezer_do_not_count(void)
	93	{
	94	if (current->mm)
	95	current->flags \|= PF_FREEZER_SKIP;
	96	}
	97
	98	/*
	99	* If the current task is a user space one, tell the freezer to count it as
	100	* freezable again and try to freeze it.
	101	*/
	102	static inline void freezer_count(void)
	103	{
	104	if (current->mm) {
	105	current->flags &= ~PF_FREEZER_SKIP;
	106	try_to_freeze();
	107	}
	108	}
	109
	110	/*
	111	* Check if the task should be counted as freezeable by the freezer
	112	*/
	113	static inline int freezer_should_skip(struct task_struct *p)
	114	{
	115	return !!(p->flags & PF_FREEZER_SKIP);
	116	}
ff39593a	117
7dfb7103 NC	118	#else
	119	static inline int frozen(struct task_struct *p) { return 0; }
	120	static inline int freezing(struct task_struct *p) { return 0; }
	121	static inline void freeze(struct task_struct *p) { BUG(); }
	122	static inline int thaw_process(struct task_struct *p) { return 1; }
7dfb7103 NC	123
	124	static inline void refrigerator(void) {}
	125	static inline int freeze_processes(void) { BUG(); return 0; }
	126	static inline void thaw_processes(void) {}
	127
	128	static inline int try_to_freeze(void) { return 0; }
	129
ba96a0c8 RW	130	static inline void freezer_do_not_count(void) {}
	131	static inline void freezer_count(void) {}
	132	static inline int freezer_should_skip(struct task_struct *p) { return 0; }
7dfb7103	133	#endif