Revert "lockdep: check that no locks held at freeze time"
[linux-3.10.git] / include / linux / freezer.h
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
11 extern atomic_t system_freezing_cnt;    /* nr of freezing conds in effect */
12 extern bool pm_freezing;                /* PM freezing in effect */
13 extern bool pm_nosig_freezing;          /* PM nosig freezing in effect */
14
15 /*
16  * Timeout for stopping processes
17  */
18 extern unsigned int freeze_timeout_msecs;
19
20 /*
21  * Check if a process has been frozen
22  */
23 static inline bool frozen(struct task_struct *p)
24 {
25         return p->flags & PF_FROZEN;
26 }
27
28 extern bool freezing_slow_path(struct task_struct *p);
29
30 /*
31  * Check if there is a request to freeze a process
32  */
33 static inline bool freezing(struct task_struct *p)
34 {
35         if (likely(!atomic_read(&system_freezing_cnt)))
36                 return false;
37         return freezing_slow_path(p);
38 }
39
40 /* Takes and releases task alloc lock using task_lock() */
41 extern void __thaw_task(struct task_struct *t);
42
43 extern bool __refrigerator(bool check_kthr_stop);
44 extern int freeze_processes(void);
45 extern int freeze_kernel_threads(void);
46 extern void thaw_processes(void);
47 extern void thaw_kernel_threads(void);
48
49 static inline bool try_to_freeze(void)
50 {
51         might_sleep();
52         if (likely(!freezing(current)))
53                 return false;
54         return __refrigerator(false);
55 }
56
57 extern bool freeze_task(struct task_struct *p);
58 extern bool set_freezable(void);
59
60 #ifdef CONFIG_CGROUP_FREEZER
61 extern bool cgroup_freezing(struct task_struct *task);
62 #else /* !CONFIG_CGROUP_FREEZER */
63 static inline bool cgroup_freezing(struct task_struct *task)
64 {
65         return false;
66 }
67 #endif /* !CONFIG_CGROUP_FREEZER */
68
69 /*
70  * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
71  * calls wait_for_completion(&vfork) and reset right after it returns from this
72  * function.  Next, the parent should call try_to_freeze() to freeze itself
73  * appropriately in case the child has exited before the freezing of tasks is
74  * complete.  However, we don't want kernel threads to be frozen in unexpected
75  * places, so we allow them to block freeze_processes() instead or to set
76  * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
77  * parent won't really block freeze_processes(), since ____call_usermodehelper()
78  * (the child) does a little before exec/exit and it can't be frozen before
79  * waking up the parent.
80  */
81
82
83 /**
84  * freezer_do_not_count - tell freezer to ignore %current
85  *
86  * Tell freezers to ignore the current task when determining whether the
87  * target frozen state is reached.  IOW, the current task will be
88  * considered frozen enough by freezers.
89  *
90  * The caller shouldn't do anything which isn't allowed for a frozen task
91  * until freezer_cont() is called.  Usually, freezer[_do_not]_count() pair
92  * wrap a scheduling operation and nothing much else.
93  */
94 static inline void freezer_do_not_count(void)
95 {
96         current->flags |= PF_FREEZER_SKIP;
97 }
98
99 /**
100  * freezer_count - tell freezer to stop ignoring %current
101  *
102  * Undo freezer_do_not_count().  It tells freezers that %current should be
103  * considered again and tries to freeze if freezing condition is already in
104  * effect.
105  */
106 static inline void freezer_count(void)
107 {
108         current->flags &= ~PF_FREEZER_SKIP;
109         /*
110          * If freezing is in progress, the following paired with smp_mb()
111          * in freezer_should_skip() ensures that either we see %true
112          * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
113          */
114         smp_mb();
115         try_to_freeze();
116 }
117
118 /**
119  * freezer_should_skip - whether to skip a task when determining frozen
120  *                       state is reached
121  * @p: task in quesion
122  *
123  * This function is used by freezers after establishing %true freezing() to
124  * test whether a task should be skipped when determining the target frozen
125  * state is reached.  IOW, if this function returns %true, @p is considered
126  * frozen enough.
127  */
128 static inline bool freezer_should_skip(struct task_struct *p)
129 {
130         /*
131          * The following smp_mb() paired with the one in freezer_count()
132          * ensures that either freezer_count() sees %true freezing() or we
133          * see cleared %PF_FREEZER_SKIP and return %false.  This makes it
134          * impossible for a task to slip frozen state testing after
135          * clearing %PF_FREEZER_SKIP.
136          */
137         smp_mb();
138         return p->flags & PF_FREEZER_SKIP;
139 }
140
141 /*
142  * These macros are intended to be used whenever you want allow a sleeping
143  * task to be frozen. Note that neither return any clear indication of
144  * whether a freeze event happened while in this function.
145  */
146
147 /* Like schedule(), but should not block the freezer. */
148 #define freezable_schedule()                                            \
149 ({                                                                      \
150         freezer_do_not_count();                                         \
151         schedule();                                                     \
152         freezer_count();                                                \
153 })
154
155 /* Like schedule_timeout_killable(), but should not block the freezer. */
156 #define freezable_schedule_timeout_killable(timeout)                    \
157 ({                                                                      \
158         long __retval;                                                  \
159         freezer_do_not_count();                                         \
160         __retval = schedule_timeout_killable(timeout);                  \
161         freezer_count();                                                \
162         __retval;                                                       \
163 })
164
165 /*
166  * Freezer-friendly wrappers around wait_event_interruptible(),
167  * wait_event_killable() and wait_event_interruptible_timeout(), originally
168  * defined in <linux/wait.h>
169  */
170
171 #define wait_event_freezekillable(wq, condition)                        \
172 ({                                                                      \
173         int __retval;                                                   \
174         freezer_do_not_count();                                         \
175         __retval = wait_event_killable(wq, (condition));                \
176         freezer_count();                                                \
177         __retval;                                                       \
178 })
179
180 #define wait_event_freezable(wq, condition)                             \
181 ({                                                                      \
182         int __retval;                                                   \
183         for (;;) {                                                      \
184                 __retval = wait_event_interruptible(wq,                 \
185                                 (condition) || freezing(current));      \
186                 if (__retval || (condition))                            \
187                         break;                                          \
188                 try_to_freeze();                                        \
189         }                                                               \
190         __retval;                                                       \
191 })
192
193 #define wait_event_freezable_timeout(wq, condition, timeout)            \
194 ({                                                                      \
195         long __retval = timeout;                                        \
196         for (;;) {                                                      \
197                 __retval = wait_event_interruptible_timeout(wq,         \
198                                 (condition) || freezing(current),       \
199                                 __retval);                              \
200                 if (__retval <= 0 || (condition))                       \
201                         break;                                          \
202                 try_to_freeze();                                        \
203         }                                                               \
204         __retval;                                                       \
205 })
206
207 #else /* !CONFIG_FREEZER */
208 static inline bool frozen(struct task_struct *p) { return false; }
209 static inline bool freezing(struct task_struct *p) { return false; }
210 static inline void __thaw_task(struct task_struct *t) {}
211
212 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
213 static inline int freeze_processes(void) { return -ENOSYS; }
214 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
215 static inline void thaw_processes(void) {}
216 static inline void thaw_kernel_threads(void) {}
217
218 static inline bool try_to_freeze_nowarn(void) { return false; }
219 static inline bool try_to_freeze(void) { return false; }
220
221 static inline void freezer_do_not_count(void) {}
222 static inline void freezer_count(void) {}
223 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
224 static inline void set_freezable(void) {}
225
226 #define freezable_schedule()  schedule()
227
228 #define freezable_schedule_timeout_killable(timeout)                    \
229         schedule_timeout_killable(timeout)
230
231 #define wait_event_freezable(wq, condition)                             \
232                 wait_event_interruptible(wq, condition)
233
234 #define wait_event_freezable_timeout(wq, condition, timeout)            \
235                 wait_event_interruptible_timeout(wq, condition, timeout)
236
237 #define wait_event_freezekillable(wq, condition)                \
238                 wait_event_killable(wq, condition)
239
240 #endif /* !CONFIG_FREEZER */
241
242 #endif  /* FREEZER_H_INCLUDED */