Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/* Freezer declarations */
2
3#ifndef FREEZER_H_INCLUDED
4#define FREEZER_H_INCLUDED
5
6#include <linux/sched.h>
7#include <linux/wait.h>
8#include <linux/atomic.h>
9
10#ifdef CONFIG_FREEZER
11extern atomic_t system_freezing_cnt; /* nr of freezing conds in effect */
12extern bool pm_freezing; /* PM freezing in effect */
13extern bool pm_nosig_freezing; /* PM nosig freezing in effect */
14
15/*
16 * Check if a process has been frozen
17 */
18static inline bool frozen(struct task_struct *p)
19{
20 return p->flags & PF_FROZEN;
21}
22
23extern bool freezing_slow_path(struct task_struct *p);
24
25/*
26 * Check if there is a request to freeze a process
27 */
28static inline bool freezing(struct task_struct *p)
29{
30 if (likely(!atomic_read(&system_freezing_cnt)))
31 return false;
32 return freezing_slow_path(p);
33}
34
35/* Takes and releases task alloc lock using task_lock() */
36extern void __thaw_task(struct task_struct *t);
37
38extern bool __refrigerator(bool check_kthr_stop);
39extern int freeze_processes(void);
40extern int freeze_kernel_threads(void);
41extern void thaw_processes(void);
42extern void thaw_kernel_threads(void);
43
44static inline bool try_to_freeze(void)
45{
46 might_sleep();
47 if (likely(!freezing(current)))
48 return false;
49 return __refrigerator(false);
50}
51
52extern bool freeze_task(struct task_struct *p);
53extern bool set_freezable(void);
54
55#ifdef CONFIG_CGROUP_FREEZER
56extern bool cgroup_freezing(struct task_struct *task);
57#else /* !CONFIG_CGROUP_FREEZER */
58static inline bool cgroup_freezing(struct task_struct *task)
59{
60 return false;
61}
62#endif /* !CONFIG_CGROUP_FREEZER */
63
64/*
65 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
66 * calls wait_for_completion(&vfork) and reset right after it returns from this
67 * function. Next, the parent should call try_to_freeze() to freeze itself
68 * appropriately in case the child has exited before the freezing of tasks is
69 * complete. However, we don't want kernel threads to be frozen in unexpected
70 * places, so we allow them to block freeze_processes() instead or to set
71 * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
72 * parent won't really block freeze_processes(), since ____call_usermodehelper()
73 * (the child) does a little before exec/exit and it can't be frozen before
74 * waking up the parent.
75 */
76
77
78/* Tell the freezer not to count the current task as freezable. */
79static inline void freezer_do_not_count(void)
80{
81 current->flags |= PF_FREEZER_SKIP;
82}
83
84/*
85 * Tell the freezer to count the current task as freezable again and try to
86 * freeze it.
87 */
88static inline void freezer_count(void)
89{
90 current->flags &= ~PF_FREEZER_SKIP;
91 try_to_freeze();
92}
93
94/*
95 * Check if the task should be counted as freezable by the freezer
96 */
97static inline int freezer_should_skip(struct task_struct *p)
98{
99 return !!(p->flags & PF_FREEZER_SKIP);
100}
101
102/*
103 * These macros are intended to be used whenever you want allow a task that's
104 * sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state to be frozen. Note
105 * that neither return any clear indication of whether a freeze event happened
106 * while in this function.
107 */
108
109/* Like schedule(), but should not block the freezer. */
110#define freezable_schedule() \
111({ \
112 freezer_do_not_count(); \
113 schedule(); \
114 freezer_count(); \
115})
116
117/* Like schedule_timeout_killable(), but should not block the freezer. */
118#define freezable_schedule_timeout_killable(timeout) \
119({ \
120 long __retval; \
121 freezer_do_not_count(); \
122 __retval = schedule_timeout_killable(timeout); \
123 freezer_count(); \
124 __retval; \
125})
126
127/*
128 * Freezer-friendly wrappers around wait_event_interruptible(),
129 * wait_event_killable() and wait_event_interruptible_timeout(), originally
130 * defined in <linux/wait.h>
131 */
132
133#define wait_event_freezekillable(wq, condition) \
134({ \
135 int __retval; \
136 freezer_do_not_count(); \
137 __retval = wait_event_killable(wq, (condition)); \
138 freezer_count(); \
139 __retval; \
140})
141
142#define wait_event_freezable(wq, condition) \
143({ \
144 int __retval; \
145 for (;;) { \
146 __retval = wait_event_interruptible(wq, \
147 (condition) || freezing(current)); \
148 if (__retval || (condition)) \
149 break; \
150 try_to_freeze(); \
151 } \
152 __retval; \
153})
154
155#define wait_event_freezable_timeout(wq, condition, timeout) \
156({ \
157 long __retval = timeout; \
158 for (;;) { \
159 __retval = wait_event_interruptible_timeout(wq, \
160 (condition) || freezing(current), \
161 __retval); \
162 if (__retval <= 0 || (condition)) \
163 break; \
164 try_to_freeze(); \
165 } \
166 __retval; \
167})
168
169#else /* !CONFIG_FREEZER */
170static inline bool frozen(struct task_struct *p) { return false; }
171static inline bool freezing(struct task_struct *p) { return false; }
172static inline void __thaw_task(struct task_struct *t) {}
173
174static inline bool __refrigerator(bool check_kthr_stop) { return false; }
175static inline int freeze_processes(void) { return -ENOSYS; }
176static inline int freeze_kernel_threads(void) { return -ENOSYS; }
177static inline void thaw_processes(void) {}
178static inline void thaw_kernel_threads(void) {}
179
180static inline bool try_to_freeze(void) { return false; }
181
182static inline void freezer_do_not_count(void) {}
183static inline void freezer_count(void) {}
184static inline int freezer_should_skip(struct task_struct *p) { return 0; }
185static inline void set_freezable(void) {}
186
187#define freezable_schedule() schedule()
188
189#define freezable_schedule_timeout_killable(timeout) \
190 schedule_timeout_killable(timeout)
191
192#define wait_event_freezable(wq, condition) \
193 wait_event_interruptible(wq, condition)
194
195#define wait_event_freezable_timeout(wq, condition, timeout) \
196 wait_event_interruptible_timeout(wq, condition, timeout)
197
198#define wait_event_freezekillable(wq, condition) \
199 wait_event_killable(wq, condition)
200
201#endif /* !CONFIG_FREEZER */
202
203#endif /* FREEZER_H_INCLUDED */