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
9#ifdef CONFIG_PM_SLEEP
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
42/*
43 * Wake up a frozen process
44 *
45 * task_lock() is taken to prevent the race with refrigerator() which may
46 * occur if the freezing of tasks fails. Namely, without the lock, if the
47 * freezing of tasks failed, thaw_tasks() might have run before a task in
48 * refrigerator() could call frozen_process(), in which case the task would be
49 * frozen and no one would thaw it.
50 */
51static inline int thaw_process(struct task_struct *p)
52{
53 task_lock(p);
54 if (frozen(p)) {
55 p->flags &= ~PF_FROZEN;
56 task_unlock(p);
57 wake_up_process(p);
58 return 1;
59 }
60 clear_freeze_flag(p);
61 task_unlock(p);
62 return 0;
63}
64
65extern void refrigerator(void);
66extern int freeze_processes(void);
67extern void thaw_processes(void);
68
69static inline int try_to_freeze(void)
70{
71 if (freezing(current)) {
72 refrigerator();
73 return 1;
74 } else
75 return 0;
76}
77
78/*
79 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
80 * calls wait_for_completion(&vfork) and reset right after it returns from this
81 * function. Next, the parent should call try_to_freeze() to freeze itself
82 * appropriately in case the child has exited before the freezing of tasks is
83 * complete. However, we don't want kernel threads to be frozen in unexpected
84 * places, so we allow them to block freeze_processes() instead or to set
85 * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
86 * parents. Fortunately, in the ____call_usermodehelper() case the parent won't
87 * really block freeze_processes(), since ____call_usermodehelper() (the child)
88 * does a little before exec/exit and it can't be frozen before waking up the
89 * parent.
90 */
91
92/*
93 * If the current task is a user space one, tell the freezer not to count it as
94 * freezable.
95 */
96static inline void freezer_do_not_count(void)
97{
98 if (current->mm)
99 current->flags |= PF_FREEZER_SKIP;
100}
101
102/*
103 * If the current task is a user space one, tell the freezer to count it as
104 * freezable again and try to freeze it.
105 */
106static inline void freezer_count(void)
107{
108 if (current->mm) {
109 current->flags &= ~PF_FREEZER_SKIP;
110 try_to_freeze();
111 }
112}
113
114/*
115 * Check if the task should be counted as freezeable by the freezer
116 */
117static inline int freezer_should_skip(struct task_struct *p)
118{
119 return !!(p->flags & PF_FREEZER_SKIP);
120}
121
122/*
123 * Tell the freezer that the current task should be frozen by it
124 */
125static inline void set_freezable(void)
126{
127 current->flags &= ~PF_NOFREEZE;
128}
129
130/*
131 * Tell the freezer that the current task should be frozen by it and that it
132 * should send a fake signal to the task to freeze it.
133 */
134static inline void set_freezable_with_signal(void)
135{
136 current->flags &= ~(PF_NOFREEZE | PF_FREEZER_NOSIG);
137}
138
139/*
140 * Freezer-friendly wrappers around wait_event_interruptible() and
141 * wait_event_interruptible_timeout(), originally defined in <linux/wait.h>
142 */
143
144#define wait_event_freezable(wq, condition) \
145({ \
146 int __retval; \
147 do { \
148 __retval = wait_event_interruptible(wq, \
149 (condition) || freezing(current)); \
150 if (__retval && !freezing(current)) \
151 break; \
152 else if (!(condition)) \
153 __retval = -ERESTARTSYS; \
154 } while (try_to_freeze()); \
155 __retval; \
156})
157
158
159#define wait_event_freezable_timeout(wq, condition, timeout) \
160({ \
161 long __retval = timeout; \
162 do { \
163 __retval = wait_event_interruptible_timeout(wq, \
164 (condition) || freezing(current), \
165 __retval); \
166 } while (try_to_freeze()); \
167 __retval; \
168})
169#else /* !CONFIG_PM_SLEEP */
170static inline int frozen(struct task_struct *p) { return 0; }
171static inline int freezing(struct task_struct *p) { return 0; }
172static inline void set_freeze_flag(struct task_struct *p) {}
173static inline void clear_freeze_flag(struct task_struct *p) {}
174static inline int thaw_process(struct task_struct *p) { return 1; }
175
176static inline void refrigerator(void) {}
177static inline int freeze_processes(void) { BUG(); return 0; }
178static inline void thaw_processes(void) {}
179
180static inline int try_to_freeze(void) { return 0; }
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) {}
186static inline void set_freezable_with_signal(void) {}
187
188#define wait_event_freezable(wq, condition) \
189 wait_event_interruptible(wq, condition)
190
191#define wait_event_freezable_timeout(wq, condition, timeout) \
192 wait_event_interruptible_timeout(wq, condition, timeout)
193
194#endif /* !CONFIG_PM_SLEEP */
195
196#endif /* FREEZER_H_INCLUDED */