[mirror_ubuntu-zesty-kernel.git] / include / linux / freezer.h

/* Freezer declarations */

#ifndef FREEZER_H_INCLUDED
#define FREEZER_H_INCLUDED

#include <linux/sched.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;
}

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