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