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

/* Freezer declarations */

#ifndef FREEZER_H_INCLUDED
#define FREEZER_H_INCLUDED

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

#ifdef CONFIG_FREEZER
extern atomic_t system_freezing_cnt;	/* nr of freezing conds in effect */
extern bool pm_freezing;		/* PM freezing in effect */
extern bool pm_nosig_freezing;		/* PM nosig freezing in effect */

/*
 * Timeout for stopping processes
 */
extern unsigned int freeze_timeout_msecs;

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

extern bool freezing_slow_path(struct task_struct *p);

/*
 * Check if there is a request to freeze a process
 */
static inline bool freezing(struct task_struct *p)
{
	if (likely(!atomic_read(&system_freezing_cnt)))
		return false;
	return freezing_slow_path(p);
}

/* Takes and releases task alloc lock using task_lock() */
extern void __thaw_task(struct task_struct *t);

extern bool __refrigerator(bool check_kthr_stop);
extern int freeze_processes(void);
extern int freeze_kernel_threads(void);
extern void thaw_processes(void);
extern void thaw_kernel_threads(void);

/*
 * DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION
 * If try_to_freeze causes a lockdep warning it means the caller may deadlock
 */
static inline bool try_to_freeze_unsafe(void)
{
	might_sleep();
	if (likely(!freezing(current)))
		return false;
	return __refrigerator(false);
}

static inline bool try_to_freeze(void)
{
	if (!(current->flags & PF_NOFREEZE))
		debug_check_no_locks_held();
	return try_to_freeze_unsafe();
}

extern bool freeze_task(struct task_struct *p);
extern bool set_freezable(void);

#ifdef CONFIG_CGROUP_FREEZER
extern bool cgroup_freezing(struct task_struct *task);
#else /* !CONFIG_CGROUP_FREEZER */
static inline bool cgroup_freezing(struct task_struct *task)
{
	return false;
}
#endif /* !CONFIG_CGROUP_FREEZER */

/*
 * 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. 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.
 */


/**
 * freezer_do_not_count - tell freezer to ignore %current
 *
 * Tell freezers to ignore the current task when determining whether the
 * target frozen state is reached.  IOW, the current task will be
 * considered frozen enough by freezers.
 *
 * The caller shouldn't do anything which isn't allowed for a frozen task
 * until freezer_cont() is called.  Usually, freezer[_do_not]_count() pair
 * wrap a scheduling operation and nothing much else.
 */
static inline void freezer_do_not_count(void)
{
	current->flags |= PF_FREEZER_SKIP;
}

/**
 * freezer_count - tell freezer to stop ignoring %current
 *
 * Undo freezer_do_not_count().  It tells freezers that %current should be
 * considered again and tries to freeze if freezing condition is already in
 * effect.
 */
static inline void freezer_count(void)
{
	current->flags &= ~PF_FREEZER_SKIP;
	/*
	 * If freezing is in progress, the following paired with smp_mb()
	 * in freezer_should_skip() ensures that either we see %true
	 * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
	 */
	smp_mb();
	try_to_freeze();
}

/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
static inline void freezer_count_unsafe(void)
{
	current->flags &= ~PF_FREEZER_SKIP;
	smp_mb();
	try_to_freeze_unsafe();
}

/**
 * freezer_should_skip - whether to skip a task when determining frozen
 *			 state is reached
 * @p: task in quesion
 *
 * This function is used by freezers after establishing %true freezing() to
 * test whether a task should be skipped when determining the target frozen
 * state is reached.  IOW, if this function returns %true, @p is considered
 * frozen enough.
 */
static inline bool freezer_should_skip(struct task_struct *p)
{
	/*
	 * The following smp_mb() paired with the one in freezer_count()
	 * ensures that either freezer_count() sees %true freezing() or we
	 * see cleared %PF_FREEZER_SKIP and return %false.  This makes it
	 * impossible for a task to slip frozen state testing after
	 * clearing %PF_FREEZER_SKIP.
	 */
	smp_mb();
	return p->flags & PF_FREEZER_SKIP;
}

/*
 * These functions are intended to be used whenever you want allow a sleeping
 * task to be frozen. Note that neither return any clear indication of
 * whether a freeze event happened while in this function.
 */

/* Like schedule(), but should not block the freezer. */
static inline void freezable_schedule(void)
{
	freezer_do_not_count();
	schedule();
	freezer_count();
}

/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
static inline void freezable_schedule_unsafe(void)
{
	freezer_do_not_count();
	schedule();
	freezer_count_unsafe();
}

/*
 * Like freezable_schedule_timeout(), but should not block the freezer.  Do not
 * call this with locks held.
 */
static inline long freezable_schedule_timeout(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout(timeout);
	freezer_count();
	return __retval;
}

/*
 * Like schedule_timeout_interruptible(), but should not block the freezer.  Do not
 * call this with locks held.
 */
static inline long freezable_schedule_timeout_interruptible(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout_interruptible(timeout);
	freezer_count();
	return __retval;
}

/* Like schedule_timeout_killable(), but should not block the freezer. */
static inline long freezable_schedule_timeout_killable(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout_killable(timeout);
	freezer_count();
	return __retval;
}

/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
static inline long freezable_schedule_timeout_killable_unsafe(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout_killable(timeout);
	freezer_count_unsafe();
	return __retval;
}

/*
 * Like schedule_hrtimeout_range(), but should not block the freezer.  Do not
 * call this with locks held.
 */
static inline int freezable_schedule_hrtimeout_range(ktime_t *expires,
		unsigned long delta, const enum hrtimer_mode mode)
{
	int __retval;
	freezer_do_not_count();
	__retval = schedule_hrtimeout_range(expires, delta, mode);
	freezer_count();
	return __retval;
}

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

#define wait_event_freezekillable(wq, condition)			\
({									\
	int __retval;							\
	freezer_do_not_count();						\
	__retval = wait_event_killable(wq, (condition));		\
	freezer_count();						\
	__retval;							\
})

/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
#define wait_event_freezekillable_unsafe(wq, condition)			\
({									\
	int __retval;							\
	freezer_do_not_count();						\
	__retval = wait_event_killable(wq, (condition));		\
	freezer_count_unsafe();						\
	__retval;							\
})

#define wait_event_freezable(wq, condition)				\
({									\
	int __retval;							\
	freezer_do_not_count();						\
	__retval = wait_event_interruptible(wq, (condition));		\
	freezer_count();						\
	__retval;							\
})

#define wait_event_freezable_timeout(wq, condition, timeout)		\
({									\
	long __retval = timeout;					\
	freezer_do_not_count();						\
	__retval = wait_event_interruptible_timeout(wq,	(condition),	\
				__retval);				\
	freezer_count();						\
	__retval;							\
})

#define wait_event_freezable_exclusive(wq, condition)			\
({									\
	int __retval;							\
	freezer_do_not_count();						\
	__retval = wait_event_interruptible_exclusive(wq, condition);	\
	freezer_count();						\
	__retval;							\
})


#else /* !CONFIG_FREEZER */
static inline bool frozen(struct task_struct *p) { return false; }
static inline bool freezing(struct task_struct *p) { return false; }
static inline void __thaw_task(struct task_struct *t) {}

static inline bool __refrigerator(bool check_kthr_stop) { return false; }
static inline int freeze_processes(void) { return -ENOSYS; }
static inline int freeze_kernel_threads(void) { return -ENOSYS; }
static inline void thaw_processes(void) {}
static inline void thaw_kernel_threads(void) {}

static inline bool try_to_freeze_nowarn(void) { return false; }
static inline bool try_to_freeze(void) { return false; }

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 freezable_schedule()  schedule()

#define freezable_schedule_unsafe()  schedule()

#define freezable_schedule_timeout(timeout)  schedule_timeout(timeout)

#define freezable_schedule_timeout_interruptible(timeout)		\
	schedule_timeout_interruptible(timeout)

#define freezable_schedule_timeout_killable(timeout)			\
	schedule_timeout_killable(timeout)

#define freezable_schedule_timeout_killable_unsafe(timeout)		\
	schedule_timeout_killable(timeout)

#define freezable_schedule_hrtimeout_range(expires, delta, mode)	\
	schedule_hrtimeout_range(expires, delta, mode)

#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)

#define wait_event_freezable_exclusive(wq, condition)			\
		wait_event_interruptible_exclusive(wq, condition)

#define wait_event_freezekillable(wq, condition)		\
		wait_event_killable(wq, condition)

#define wait_event_freezekillable_unsafe(wq, condition)			\
		wait_event_killable(wq, condition)

#endif /* !CONFIG_FREEZER */

#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
0f9548ca	6	#include <linux/debug_locks.h>
5c543eff	7	#include <linux/sched.h>
e42837bc	8	#include <linux/wait.h>
a3201227	9	#include <linux/atomic.h>
5c543eff	10
8174f150	11	#ifdef CONFIG_FREEZER
a3201227 TH	12	extern atomic_t system_freezing_cnt; /* nr of freezing conds in effect */
	13	extern bool pm_freezing; /* PM freezing in effect */
	14	extern bool pm_nosig_freezing; /* PM nosig freezing in effect */
	15
957d1282 LF	16	/*
	17	* Timeout for stopping processes
	18	*/
	19	extern unsigned int freeze_timeout_msecs;
	20
7dfb7103 NC	21	/*
	22	* Check if a process has been frozen
	23	*/
948246f7	24	static inline bool frozen(struct task_struct *p)
7dfb7103 NC	25	{
	26	return p->flags & PF_FROZEN;
	27	}
	28
a3201227	29	extern bool freezing_slow_path(struct task_struct *p);
7dfb7103 NC	30
7dfb7103 NC	31	/*
a3201227	32	* Check if there is a request to freeze a process
7dfb7103	33	*/
a3201227	34	static inline bool freezing(struct task_struct *p)
7dfb7103	35	{
a3201227 TH	36	if (likely(!atomic_read(&system_freezing_cnt)))
	37	return false;
	38	return freezing_slow_path(p);
7dfb7103 NC	39	}
7dfb7103 NC	40
dc52ddc0	41	/* Takes and releases task alloc lock using task_lock() */
a5be2d0d	42	extern void __thaw_task(struct task_struct *t);
7dfb7103	43
8a32c441	44	extern bool __refrigerator(bool check_kthr_stop);
7dfb7103	45	extern int freeze_processes(void);
2aede851	46	extern int freeze_kernel_threads(void);
a9b6f562	47	extern void thaw_processes(void);
181e9bde	48	extern void thaw_kernel_threads(void);
7dfb7103	49
416ad3c9 CC	50	/*
	51	* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION
	52	* If try_to_freeze causes a lockdep warning it means the caller may deadlock
	53	*/
	54	static inline bool try_to_freeze_unsafe(void)
7dfb7103	55	{
a0acae0e TH	56	might_sleep();
	57	if (likely(!freezing(current)))
	58	return false;
8a32c441	59	return __refrigerator(false);
7dfb7103	60	}
ff39593a	61
416ad3c9 CC	62	static inline bool try_to_freeze(void)
416ad3c9 CC	63	{
0f9548ca MSB	64	if (!(current->flags & PF_NOFREEZE))
0f9548ca MSB	65	debug_check_no_locks_held();
416ad3c9 CC	66	return try_to_freeze_unsafe();
	67	}
	68
839e3407	69	extern bool freeze_task(struct task_struct *p);
34b087e4	70	extern bool set_freezable(void);
8174f150	71
dc52ddc0	72	#ifdef CONFIG_CGROUP_FREEZER
22b4e111	73	extern bool cgroup_freezing(struct task_struct *task);
dc52ddc0	74	#else /* !CONFIG_CGROUP_FREEZER */
22b4e111	75	static inline bool cgroup_freezing(struct task_struct *task)
5a7aadfe	76	{
22b4e111	77	return false;
5a7aadfe	78	}
dc52ddc0 MH	79	#endif /* !CONFIG_CGROUP_FREEZER */
dc52ddc0 MH	80
ba96a0c8 RW	81	/*
	82	* The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
	83	* calls wait_for_completion(&vfork) and reset right after it returns from this
	84	* function. Next, the parent should call try_to_freeze() to freeze itself
	85	* appropriately in case the child has exited before the freezing of tasks is
	86	* complete. However, we don't want kernel threads to be frozen in unexpected
	87	* places, so we allow them to block freeze_processes() instead or to set
467de1fc SB	88	* PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
	89	* parent won't really block freeze_processes(), since ____call_usermodehelper()
	90	* (the child) does a little before exec/exit and it can't be frozen before
	91	* waking up the parent.
ba96a0c8 RW	92	*/
ba96a0c8 RW	93
467de1fc	94
dd67d32d TH	95	/**
	96	* freezer_do_not_count - tell freezer to ignore %current
	97	*
	98	* Tell freezers to ignore the current task when determining whether the
	99	* target frozen state is reached. IOW, the current task will be
	100	* considered frozen enough by freezers.
	101	*
	102	* The caller shouldn't do anything which isn't allowed for a frozen task
	103	* until freezer_cont() is called. Usually, freezer[_do_not]_count() pair
	104	* wrap a scheduling operation and nothing much else.
	105	*/
ba96a0c8 RW	106	static inline void freezer_do_not_count(void)
ba96a0c8 RW	107	{
467de1fc	108	current->flags \|= PF_FREEZER_SKIP;
ba96a0c8 RW	109	}
ba96a0c8 RW	110
dd67d32d TH	111	/**
	112	* freezer_count - tell freezer to stop ignoring %current
	113	*
	114	* Undo freezer_do_not_count(). It tells freezers that %current should be
	115	* considered again and tries to freeze if freezing condition is already in
	116	* effect.
ba96a0c8 RW	117	*/
	118	static inline void freezer_count(void)
	119	{
467de1fc	120	current->flags &= ~PF_FREEZER_SKIP;
dd67d32d TH	121	/*
	122	* If freezing is in progress, the following paired with smp_mb()
	123	* in freezer_should_skip() ensures that either we see %true
	124	* freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
	125	*/
	126	smp_mb();
467de1fc	127	try_to_freeze();
ba96a0c8 RW	128	}
ba96a0c8 RW	129
416ad3c9 CC	130	/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
	131	static inline void freezer_count_unsafe(void)
	132	{
	133	current->flags &= ~PF_FREEZER_SKIP;
	134	smp_mb();
	135	try_to_freeze_unsafe();
	136	}
	137
dd67d32d TH	138	/**
	139	* freezer_should_skip - whether to skip a task when determining frozen
	140	* state is reached
	141	* @p: task in quesion
	142	*
	143	* This function is used by freezers after establishing %true freezing() to
	144	* test whether a task should be skipped when determining the target frozen
	145	* state is reached. IOW, if this function returns %true, @p is considered
	146	* frozen enough.
ba96a0c8	147	*/
dd67d32d	148	static inline bool freezer_should_skip(struct task_struct *p)
ba96a0c8	149	{
dd67d32d TH	150	/*
	151	* The following smp_mb() paired with the one in freezer_count()
	152	* ensures that either freezer_count() sees %true freezing() or we
	153	* see cleared %PF_FREEZER_SKIP and return %false. This makes it
	154	* impossible for a task to slip frozen state testing after
	155	* clearing %PF_FREEZER_SKIP.
	156	*/
	157	smp_mb();
	158	return p->flags & PF_FREEZER_SKIP;
ba96a0c8	159	}
ff39593a	160
d310310c	161	/*
8ee492d6	162	* These functions are intended to be used whenever you want allow a sleeping
5d8f72b5 ON	163	* task to be frozen. Note that neither return any clear indication of
5d8f72b5 ON	164	* whether a freeze event happened while in this function.
d310310c JL	165	*/
	166
	167	/* Like schedule(), but should not block the freezer. */
8ee492d6 CC	168	static inline void freezable_schedule(void)
	169	{
	170	freezer_do_not_count();
	171	schedule();
	172	freezer_count();
	173	}
d310310c	174
416ad3c9	175	/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
8ee492d6 CC	176	static inline void freezable_schedule_unsafe(void)
	177	{
	178	freezer_do_not_count();
	179	schedule();
	180	freezer_count_unsafe();
	181	}
416ad3c9	182
dd5ec0f4 CC	183	/*
	184	* Like freezable_schedule_timeout(), but should not block the freezer. Do not
	185	* call this with locks held.
	186	*/
	187	static inline long freezable_schedule_timeout(long timeout)
	188	{
	189	long __retval;
	190	freezer_do_not_count();
	191	__retval = schedule_timeout(timeout);
	192	freezer_count();
	193	return __retval;
	194	}
	195
	196	/*
	197	* Like schedule_timeout_interruptible(), but should not block the freezer. Do not
	198	* call this with locks held.
	199	*/
	200	static inline long freezable_schedule_timeout_interruptible(long timeout)
	201	{
	202	long __retval;
	203	freezer_do_not_count();
	204	__retval = schedule_timeout_interruptible(timeout);
	205	freezer_count();
	206	return __retval;
	207	}
	208
d310310c	209	/* Like schedule_timeout_killable(), but should not block the freezer. */
8ee492d6 CC	210	static inline long freezable_schedule_timeout_killable(long timeout)
	211	{
	212	long __retval;
	213	freezer_do_not_count();
	214	__retval = schedule_timeout_killable(timeout);
	215	freezer_count();
	216	return __retval;
	217	}
d310310c	218
416ad3c9	219	/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
8ee492d6 CC	220	static inline long freezable_schedule_timeout_killable_unsafe(long timeout)
	221	{
	222	long __retval;
	223	freezer_do_not_count();
	224	__retval = schedule_timeout_killable(timeout);
	225	freezer_count_unsafe();
	226	return __retval;
	227	}
416ad3c9	228
dd5ec0f4 CC	229	/*
	230	* Like schedule_hrtimeout_range(), but should not block the freezer. Do not
	231	* call this with locks held.
	232	*/
	233	static inline int freezable_schedule_hrtimeout_range(ktime_t *expires,
	234	unsigned long delta, const enum hrtimer_mode mode)
	235	{
	236	int __retval;
	237	freezer_do_not_count();
	238	__retval = schedule_hrtimeout_range(expires, delta, mode);
	239	freezer_count();
	240	return __retval;
	241	}
	242
e42837bc	243	/*
f06ac72e JL	244	* Freezer-friendly wrappers around wait_event_interruptible(),
	245	* wait_event_killable() and wait_event_interruptible_timeout(), originally
	246	* defined in <linux/wait.h>
e42837bc RW	247	*/
e42837bc RW	248
f06ac72e JL	249	#define wait_event_freezekillable(wq, condition) \
	250	({ \
	251	int __retval; \
6f35c4ab ON	252	freezer_do_not_count(); \
	253	__retval = wait_event_killable(wq, (condition)); \
	254	freezer_count(); \
f06ac72e JL	255	__retval; \
	256	})
	257
5853cc2a CC	258	/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
	259	#define wait_event_freezekillable_unsafe(wq, condition) \
	260	({ \
	261	int __retval; \
	262	freezer_do_not_count(); \
	263	__retval = wait_event_killable(wq, (condition)); \
	264	freezer_count_unsafe(); \
	265	__retval; \
	266	})
	267
e42837bc RW	268	#define wait_event_freezable(wq, condition) \
	269	({ \
	270	int __retval; \
b0123586 CC	271	freezer_do_not_count(); \
	272	__retval = wait_event_interruptible(wq, (condition)); \
	273	freezer_count(); \
e42837bc RW	274	__retval; \
	275	})
	276
e42837bc RW	277	#define wait_event_freezable_timeout(wq, condition, timeout) \
	278	({ \
	279	long __retval = timeout; \
b0123586 CC	280	freezer_do_not_count(); \
	281	__retval = wait_event_interruptible_timeout(wq, (condition), \
	282	__retval); \
	283	freezer_count(); \
e42837bc RW	284	__retval; \
e42837bc RW	285	})
24b7ead3	286
dd5ec0f4 CC	287	#define wait_event_freezable_exclusive(wq, condition) \
	288	({ \
	289	int __retval; \
	290	freezer_do_not_count(); \
	291	__retval = wait_event_interruptible_exclusive(wq, condition); \
	292	freezer_count(); \
	293	__retval; \
	294	})
	295
	296
8174f150	297	#else /* !CONFIG_FREEZER */
948246f7	298	static inline bool frozen(struct task_struct *p) { return false; }
a3201227	299	static inline bool freezing(struct task_struct *p) { return false; }
62c9ea6b	300	static inline void __thaw_task(struct task_struct *t) {}
7dfb7103	301
8a32c441	302	static inline bool __refrigerator(bool check_kthr_stop) { return false; }
2aede851 RW	303	static inline int freeze_processes(void) { return -ENOSYS; }
2aede851 RW	304	static inline int freeze_kernel_threads(void) { return -ENOSYS; }
7dfb7103	305	static inline void thaw_processes(void) {}
181e9bde	306	static inline void thaw_kernel_threads(void) {}
7dfb7103	307
e5f57621	308	static inline bool try_to_freeze_nowarn(void) { return false; }
a0acae0e	309	static inline bool try_to_freeze(void) { return false; }
7dfb7103	310
ba96a0c8 RW	311	static inline void freezer_do_not_count(void) {}
	312	static inline void freezer_count(void) {}
	313	static inline int freezer_should_skip(struct task_struct *p) { return 0; }
83144186	314	static inline void set_freezable(void) {}
e42837bc	315
d310310c JL	316	#define freezable_schedule() schedule()
d310310c JL	317
416ad3c9 CC	318	#define freezable_schedule_unsafe() schedule()
416ad3c9 CC	319
dd5ec0f4 CC	320	#define freezable_schedule_timeout(timeout) schedule_timeout(timeout)
	321
	322	#define freezable_schedule_timeout_interruptible(timeout) \
	323	schedule_timeout_interruptible(timeout)
	324
d310310c JL	325	#define freezable_schedule_timeout_killable(timeout) \
	326	schedule_timeout_killable(timeout)
	327
416ad3c9 CC	328	#define freezable_schedule_timeout_killable_unsafe(timeout) \
	329	schedule_timeout_killable(timeout)
	330
dd5ec0f4 CC	331	#define freezable_schedule_hrtimeout_range(expires, delta, mode) \
	332	schedule_hrtimeout_range(expires, delta, mode)
	333
e42837bc RW	334	#define wait_event_freezable(wq, condition) \
	335	wait_event_interruptible(wq, condition)
	336
	337	#define wait_event_freezable_timeout(wq, condition, timeout) \
	338	wait_event_interruptible_timeout(wq, condition, timeout)
	339
dd5ec0f4 CC	340	#define wait_event_freezable_exclusive(wq, condition) \
	341	wait_event_interruptible_exclusive(wq, condition)
	342
e0c8ea1a SF	343	#define wait_event_freezekillable(wq, condition) \
	344	wait_event_killable(wq, condition)
	345
5853cc2a CC	346	#define wait_event_freezekillable_unsafe(wq, condition) \
	347	wait_event_killable(wq, condition)
	348
8174f150	349	#endif /* !CONFIG_FREEZER */
83144186 RW	350
83144186 RW	351	#endif /* FREEZER_H_INCLUDED */