[linux-2.6-block.git] / include / linux / freezer.h

/* Freezer declarations */

#ifndef FREEZER_H_INCLUDED
#define FREEZER_H_INCLUDED

#include <linux/sched.h>
#include <linux/wait.h>

#ifdef CONFIG_PM_SLEEP
/*
 * 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 set_freeze_flag(struct task_struct *p)
{
	set_tsk_thread_flag(p, TIF_FREEZE);
}

/*
 * Sometimes we may need to cancel the previous 'freeze' request
 */
static inline void clear_freeze_flag(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_freeze_flag(p);
	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);
}

/*
 * Tell the freezer that the current task should be frozen by it
 */
static inline void set_freezable(void)
{
	current->flags &= ~PF_NOFREEZE;
}

/*
 * Freezer-friendly wrappers around wait_event_interruptible() and
 * wait_event_interruptible_timeout(), originally defined in <linux/wait.h>
 */

#define wait_event_freezable(wq, condition)				\
({									\
	int __retval;							\
	do {								\
		__retval = wait_event_interruptible(wq, 		\
				(condition) || freezing(current));	\
		if (__retval && !freezing(current))			\
			break;						\
		else if (!(condition))					\
			__retval = -ERESTARTSYS;			\
	} while (try_to_freeze());					\
	__retval;							\
})


#define wait_event_freezable_timeout(wq, condition, timeout)		\
({									\
	long __retval = timeout;					\
	do {								\
		__retval = wait_event_interruptible_timeout(wq,		\
				(condition) || freezing(current),	\
				__retval); 				\
	} while (try_to_freeze());					\
	__retval;							\
})
#else /* !CONFIG_PM_SLEEP */
static inline int frozen(struct task_struct *p) { return 0; }
static inline int freezing(struct task_struct *p) { return 0; }
static inline void set_freeze_flag(struct task_struct *p) {}
static inline void clear_freeze_flag(struct task_struct *p) {}
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; }
static inline void set_freezable(void) {}

#define wait_event_freezable(wq, condition)				\
		wait_event_interruptible(wq, condition)

#define wait_event_freezable_timeout(wq, condition, timeout)		\
		wait_event_interruptible_timeout(wq, condition, timeout)

#endif /* !CONFIG_PM_SLEEP */

#endif	/* FREEZER_H_INCLUDED */
Commit	Line	Data
7dfb7103 NC	1	/* Freezer declarations */
7dfb7103 NC	2
83144186 RW	3	#ifndef FREEZER_H_INCLUDED
	4	#define FREEZER_H_INCLUDED
	5
5c543eff	6	#include <linux/sched.h>
e42837bc	7	#include <linux/wait.h>
5c543eff	8
296699de	9	#ifdef CONFIG_PM_SLEEP
7dfb7103 NC	10	/*
	11	* Check if a process has been frozen
	12	*/
	13	static inline int frozen(struct task_struct *p)
	14	{
	15	return p->flags & PF_FROZEN;
	16	}
	17
	18	/*
	19	* Check if there is a request to freeze a process
	20	*/
	21	static inline int freezing(struct task_struct *p)
	22	{
8a102eed	23	return test_tsk_thread_flag(p, TIF_FREEZE);
7dfb7103 NC	24	}
	25
	26	/*
	27	* Request that a process be frozen
7dfb7103	28	*/
0c1eecfb	29	static inline void set_freeze_flag(struct task_struct *p)
7dfb7103	30	{
8a102eed	31	set_tsk_thread_flag(p, TIF_FREEZE);
7dfb7103 NC	32	}
	33
	34	/*
	35	* Sometimes we may need to cancel the previous 'freeze' request
	36	*/
0c1eecfb	37	static inline void clear_freeze_flag(struct task_struct *p)
7dfb7103	38	{
8a102eed	39	clear_tsk_thread_flag(p, TIF_FREEZE);
7dfb7103 NC	40	}
	41
	42	/*
	43	* Wake up a frozen process
33e1c288 RW	44	*
	45	* task_lock() is taken to prevent the race with refrigerator() which may
	46	* occur if the freezing of tasks fails. Namely, without the lock, if the
	47	* freezing of tasks failed, thaw_tasks() might have run before a task in
	48	* refrigerator() could call frozen_process(), in which case the task would be
	49	* frozen and no one would thaw it.
7dfb7103 NC	50	*/
	51	static inline int thaw_process(struct task_struct *p)
	52	{
33e1c288	53	task_lock(p);
7dfb7103 NC	54	if (frozen(p)) {
7dfb7103 NC	55	p->flags &= ~PF_FROZEN;
33e1c288	56	task_unlock(p);
7dfb7103 NC	57	wake_up_process(p);
	58	return 1;
	59	}
0c1eecfb	60	clear_freeze_flag(p);
33e1c288	61	task_unlock(p);
7dfb7103 NC	62	return 0;
	63	}
	64
7dfb7103 NC	65	extern void refrigerator(void);
7dfb7103 NC	66	extern int freeze_processes(void);
a9b6f562	67	extern void thaw_processes(void);
7dfb7103 NC	68
	69	static inline int try_to_freeze(void)
	70	{
	71	if (freezing(current)) {
	72	refrigerator();
	73	return 1;
	74	} else
	75	return 0;
	76	}
ff39593a	77
ba96a0c8 RW	78	/*
	79	* The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
	80	* calls wait_for_completion(&vfork) and reset right after it returns from this
	81	* function. Next, the parent should call try_to_freeze() to freeze itself
	82	* appropriately in case the child has exited before the freezing of tasks is
	83	* complete. However, we don't want kernel threads to be frozen in unexpected
	84	* places, so we allow them to block freeze_processes() instead or to set
	85	* PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
	86	* parents. Fortunately, in the ____call_usermodehelper() case the parent won't
	87	* really block freeze_processes(), since ____call_usermodehelper() (the child)
	88	* does a little before exec/exit and it can't be frozen before waking up the
	89	* parent.
	90	*/
	91
	92	/*
	93	* If the current task is a user space one, tell the freezer not to count it as
	94	* freezable.
	95	*/
	96	static inline void freezer_do_not_count(void)
	97	{
	98	if (current->mm)
	99	current->flags \|= PF_FREEZER_SKIP;
	100	}
	101
	102	/*
	103	* If the current task is a user space one, tell the freezer to count it as
	104	* freezable again and try to freeze it.
	105	*/
	106	static inline void freezer_count(void)
	107	{
	108	if (current->mm) {
	109	current->flags &= ~PF_FREEZER_SKIP;
	110	try_to_freeze();
	111	}
	112	}
	113
	114	/*
	115	* Check if the task should be counted as freezeable by the freezer
	116	*/
	117	static inline int freezer_should_skip(struct task_struct *p)
	118	{
	119	return !!(p->flags & PF_FREEZER_SKIP);
	120	}
ff39593a	121
83144186 RW	122	/*
	123	* Tell the freezer that the current task should be frozen by it
	124	*/
	125	static inline void set_freezable(void)
	126	{
	127	current->flags &= ~PF_NOFREEZE;
	128	}
	129
e42837bc RW	130	/*
	131	* Freezer-friendly wrappers around wait_event_interruptible() and
	132	* wait_event_interruptible_timeout(), originally defined in <linux/wait.h>
	133	*/
	134
	135	#define wait_event_freezable(wq, condition) \
	136	({ \
	137	int __retval; \
	138	do { \
	139	__retval = wait_event_interruptible(wq, \
	140	(condition) \|\| freezing(current)); \
	141	if (__retval && !freezing(current)) \
	142	break; \
	143	else if (!(condition)) \
	144	__retval = -ERESTARTSYS; \
	145	} while (try_to_freeze()); \
	146	__retval; \
	147	})
	148
	149
	150	#define wait_event_freezable_timeout(wq, condition, timeout) \
	151	({ \
	152	long __retval = timeout; \
	153	do { \
	154	__retval = wait_event_interruptible_timeout(wq, \
	155	(condition) \|\| freezing(current), \
	156	__retval); \
	157	} while (try_to_freeze()); \
	158	__retval; \
	159	})
296699de	160	#else /* !CONFIG_PM_SLEEP */
7dfb7103 NC	161	static inline int frozen(struct task_struct *p) { return 0; }
7dfb7103 NC	162	static inline int freezing(struct task_struct *p) { return 0; }
0c1eecfb RW	163	static inline void set_freeze_flag(struct task_struct *p) {}
0c1eecfb RW	164	static inline void clear_freeze_flag(struct task_struct *p) {}
7dfb7103	165	static inline int thaw_process(struct task_struct *p) { return 1; }
7dfb7103 NC	166
	167	static inline void refrigerator(void) {}
	168	static inline int freeze_processes(void) { BUG(); return 0; }
	169	static inline void thaw_processes(void) {}
	170
	171	static inline int try_to_freeze(void) { return 0; }
	172
ba96a0c8 RW	173	static inline void freezer_do_not_count(void) {}
	174	static inline void freezer_count(void) {}
	175	static inline int freezer_should_skip(struct task_struct *p) { return 0; }
83144186	176	static inline void set_freezable(void) {}
e42837bc RW	177
	178	#define wait_event_freezable(wq, condition) \
	179	wait_event_interruptible(wq, condition)
	180
	181	#define wait_event_freezable_timeout(wq, condition, timeout) \
	182	wait_event_interruptible_timeout(wq, condition, timeout)
	183
296699de	184	#endif /* !CONFIG_PM_SLEEP */
83144186 RW	185
83144186 RW	186	#endif /* FREEZER_H_INCLUDED */