tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
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
9#ifdef CONFIG_FREEZER
10/*
11 * Check if a process has been frozen
12 */
13static 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 */
21static inline int freezing(struct task_struct *p)
22{
23 return test_tsk_thread_flag(p, TIF_FREEZE);
24}
25
26/*
27 * Request that a process be frozen
28 */
29static inline void set_freeze_flag(struct task_struct *p)
30{
31 set_tsk_thread_flag(p, TIF_FREEZE);
32}
33
34/*
35 * Sometimes we may need to cancel the previous 'freeze' request
36 */
37static inline void clear_freeze_flag(struct task_struct *p)
38{
39 clear_tsk_thread_flag(p, TIF_FREEZE);
40}
41
42static inline bool should_send_signal(struct task_struct *p)
43{
44 return !(p->flags & PF_FREEZER_NOSIG);
45}
46
47/*
48 * Wake up a frozen process
49 */
50extern int __thaw_process(struct task_struct *p);
51
52/* Takes and releases task alloc lock using task_lock() */
53extern int thaw_process(struct task_struct *p);
54
55extern void refrigerator(void);
56extern int freeze_processes(void);
57extern void thaw_processes(void);
58
59static inline int try_to_freeze(void)
60{
61 if (freezing(current)) {
62 refrigerator();
63 return 1;
64 } else
65 return 0;
66}
67
68extern bool freeze_task(struct task_struct *p, bool sig_only);
69extern void cancel_freezing(struct task_struct *p);
70
71#ifdef CONFIG_CGROUP_FREEZER
72extern int cgroup_frozen(struct task_struct *task);
73#else /* !CONFIG_CGROUP_FREEZER */
74static inline int cgroup_frozen(struct task_struct *task) { return 0; }
75#endif /* !CONFIG_CGROUP_FREEZER */
76
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 */
95static 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 */
105static 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 */
116static inline int freezer_should_skip(struct task_struct *p)
117{
118 return !!(p->flags & PF_FREEZER_SKIP);
119}
120
121/*
122 * Tell the freezer that the current task should be frozen by it
123 */
124static inline void set_freezable(void)
125{
126 current->flags &= ~PF_NOFREEZE;
127}
128
129/*
130 * Tell the freezer that the current task should be frozen by it and that it
131 * should send a fake signal to the task to freeze it.
132 */
133static inline void set_freezable_with_signal(void)
134{
135 current->flags &= ~(PF_NOFREEZE | PF_FREEZER_NOSIG);
136}
137
138/*
139 * Freezer-friendly wrappers around wait_event_interruptible() and
140 * wait_event_interruptible_timeout(), originally defined in <linux/wait.h>
141 */
142
143#define wait_event_freezable(wq, condition) \
144({ \
145 int __retval; \
146 do { \
147 __retval = wait_event_interruptible(wq, \
148 (condition) || freezing(current)); \
149 if (__retval && !freezing(current)) \
150 break; \
151 else if (!(condition)) \
152 __retval = -ERESTARTSYS; \
153 } while (try_to_freeze()); \
154 __retval; \
155})
156
157
158#define wait_event_freezable_timeout(wq, condition, timeout) \
159({ \
160 long __retval = timeout; \
161 do { \
162 __retval = wait_event_interruptible_timeout(wq, \
163 (condition) || freezing(current), \
164 __retval); \
165 } while (try_to_freeze()); \
166 __retval; \
167})
168#else /* !CONFIG_FREEZER */
169static inline int frozen(struct task_struct *p) { return 0; }
170static inline int freezing(struct task_struct *p) { return 0; }
171static inline void set_freeze_flag(struct task_struct *p) {}
172static inline void clear_freeze_flag(struct task_struct *p) {}
173static inline int thaw_process(struct task_struct *p) { return 1; }
174
175static inline void refrigerator(void) {}
176static inline int freeze_processes(void) { BUG(); return 0; }
177static inline void thaw_processes(void) {}
178
179static inline int try_to_freeze(void) { return 0; }
180
181static inline void freezer_do_not_count(void) {}
182static inline void freezer_count(void) {}
183static inline int freezer_should_skip(struct task_struct *p) { return 0; }
184static inline void set_freezable(void) {}
185static inline void set_freezable_with_signal(void) {}
186
187#define wait_event_freezable(wq, condition) \
188 wait_event_interruptible(wq, condition)
189
190#define wait_event_freezable_timeout(wq, condition, timeout) \
191 wait_event_interruptible_timeout(wq, condition, timeout)
192
193#endif /* !CONFIG_FREEZER */
194
195#endif /* FREEZER_H_INCLUDED */