freezer.h 8.64 KB
Newer Older
1 2
/* Freezer declarations */

3 4 5
#ifndef FREEZER_H_INCLUDED
#define FREEZER_H_INCLUDED

6
#include <linux/debug_locks.h>
7
#include <linux/sched.h>
8
#include <linux/wait.h>
9
#include <linux/atomic.h>
10

11
#ifdef CONFIG_FREEZER
12 13 14 15
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 */

16 17 18 19 20
/*
 * Timeout for stopping processes
 */
extern unsigned int freeze_timeout_msecs;

21 22 23
/*
 * Check if a process has been frozen
 */
24
static inline bool frozen(struct task_struct *p)
25 26 27 28
{
	return p->flags & PF_FROZEN;
}

29
extern bool freezing_slow_path(struct task_struct *p);
30 31

/*
32
 * Check if there is a request to freeze a process
33
 */
34
static inline bool freezing(struct task_struct *p)
35
{
36 37 38
	if (likely(!atomic_read(&system_freezing_cnt)))
		return false;
	return freezing_slow_path(p);
39 40
}

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

44
extern bool __refrigerator(bool check_kthr_stop);
45
extern int freeze_processes(void);
46
extern int freeze_kernel_threads(void);
47
extern void thaw_processes(void);
48
extern void thaw_kernel_threads(void);
49

50 51 52 53 54
/*
 * 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)
55
{
56 57 58
	might_sleep();
	if (likely(!freezing(current)))
		return false;
59
	return __refrigerator(false);
60
}
61

62 63
static inline bool try_to_freeze(void)
{
64 65
	if (!(current->flags & PF_NOFREEZE))
		debug_check_no_locks_held();
66 67 68
	return try_to_freeze_unsafe();
}

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

72
#ifdef CONFIG_CGROUP_FREEZER
73
extern bool cgroup_freezing(struct task_struct *task);
74
#else /* !CONFIG_CGROUP_FREEZER */
75
static inline bool cgroup_freezing(struct task_struct *task)
76
{
77
	return false;
78
}
79 80
#endif /* !CONFIG_CGROUP_FREEZER */

81 82 83 84 85 86 87
/*
 * 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
88 89 90 91
 * 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.
92 93
 */

94

95 96 97 98 99 100 101 102 103 104 105
/**
 * 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.
 */
106 107
static inline void freezer_do_not_count(void)
{
108
	current->flags |= PF_FREEZER_SKIP;
109 110
}

111 112 113 114 115 116
/**
 * 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.
117 118 119
 */
static inline void freezer_count(void)
{
120
	current->flags &= ~PF_FREEZER_SKIP;
121 122 123 124 125 126
	/*
	 * 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();
127
	try_to_freeze();
128 129
}

130 131 132 133 134 135 136 137
/* 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();
}

138 139 140 141 142 143 144 145 146
/**
 * 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.
147
 */
148
static inline bool freezer_should_skip(struct task_struct *p)
149
{
150 151 152 153 154 155 156 157 158
	/*
	 * 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;
159
}
160

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

/* Like schedule(), but should not block the freezer. */
168 169 170 171 172 173
static inline void freezable_schedule(void)
{
	freezer_do_not_count();
	schedule();
	freezer_count();
}
174

175
/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
176 177 178 179 180 181
static inline void freezable_schedule_unsafe(void)
{
	freezer_do_not_count();
	schedule();
	freezer_count_unsafe();
}
182

183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
/*
 * 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;
}

209
/* Like schedule_timeout_killable(), but should not block the freezer. */
210 211 212 213 214 215 216 217
static inline long freezable_schedule_timeout_killable(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout_killable(timeout);
	freezer_count();
	return __retval;
}
218

219
/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
220 221 222 223 224 225 226 227
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;
}
228

229 230 231 232 233
/*
 * 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,
234
		u64 delta, const enum hrtimer_mode mode)
235 236 237 238 239 240 241 242
{
	int __retval;
	freezer_do_not_count();
	__retval = schedule_hrtimeout_range(expires, delta, mode);
	freezer_count();
	return __retval;
}

243
/*
244 245 246
 * Freezer-friendly wrappers around wait_event_interruptible(),
 * wait_event_killable() and wait_event_interruptible_timeout(), originally
 * defined in <linux/wait.h>
247 248
 */

249 250 251 252 253 254 255 256 257 258
/* 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;							\
})

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

264
static inline bool __refrigerator(bool check_kthr_stop) { return false; }
265 266
static inline int freeze_processes(void) { return -ENOSYS; }
static inline int freeze_kernel_threads(void) { return -ENOSYS; }
267
static inline void thaw_processes(void) {}
268
static inline void thaw_kernel_threads(void) {}
269

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

273 274 275
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; }
276
static inline void set_freezable(void) {}
277

278 279
#define freezable_schedule()  schedule()

280 281
#define freezable_schedule_unsafe()  schedule()

282 283 284 285 286
#define freezable_schedule_timeout(timeout)  schedule_timeout(timeout)

#define freezable_schedule_timeout_interruptible(timeout)		\
	schedule_timeout_interruptible(timeout)

287 288 289
#define freezable_schedule_timeout_killable(timeout)			\
	schedule_timeout_killable(timeout)

290 291 292
#define freezable_schedule_timeout_killable_unsafe(timeout)		\
	schedule_timeout_killable(timeout)

293 294 295
#define freezable_schedule_hrtimeout_range(expires, delta, mode)	\
	schedule_hrtimeout_range(expires, delta, mode)

296 297 298
#define wait_event_freezekillable_unsafe(wq, condition)			\
		wait_event_killable(wq, condition)

299
#endif /* !CONFIG_FREEZER */
300 301

#endif	/* FREEZER_H_INCLUDED */