Merge git://git.kernel.org/pub/scm/linux/kernel/git/mingo/linux-2.6-sched
[linux-2.6] / 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_PM_SLEEP
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 /*
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  */
51 static 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
65 extern void refrigerator(void);
66 extern int freeze_processes(void);
67 extern void thaw_processes(void);
68
69 static 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  */
96 static 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  */
106 static 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  */
117 static 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  */
125 static inline void set_freezable(void)
126 {
127         current->flags &= ~PF_NOFREEZE;
128 }
129
130 /*
131  * Freezer-friendly wrappers around wait_event_interruptible() and
132  * wait_event_interruptible_timeout(), originally defined in <linux/wait.h>
133  */
134
135 #define wait_event_freezable(wq, condition)                             \
136 ({                                                                      \
137         int __retval;                                                   \
138         do {                                                            \
139                 __retval = wait_event_interruptible(wq,                 \
140                                 (condition) || freezing(current));      \
141                 if (__retval && !freezing(current))                     \
142                         break;                                          \
143                 else if (!(condition))                                  \
144                         __retval = -ERESTARTSYS;                        \
145         } while (try_to_freeze());                                      \
146         __retval;                                                       \
147 })
148
149
150 #define wait_event_freezable_timeout(wq, condition, timeout)            \
151 ({                                                                      \
152         long __retval = timeout;                                        \
153         do {                                                            \
154                 __retval = wait_event_interruptible_timeout(wq,         \
155                                 (condition) || freezing(current),       \
156                                 __retval);                              \
157         } while (try_to_freeze());                                      \
158         __retval;                                                       \
159 })
160 #else /* !CONFIG_PM_SLEEP */
161 static inline int frozen(struct task_struct *p) { return 0; }
162 static inline int freezing(struct task_struct *p) { return 0; }
163 static inline void set_freeze_flag(struct task_struct *p) {}
164 static inline void clear_freeze_flag(struct task_struct *p) {}
165 static inline int thaw_process(struct task_struct *p) { return 1; }
166
167 static inline void refrigerator(void) {}
168 static inline int freeze_processes(void) { BUG(); return 0; }
169 static inline void thaw_processes(void) {}
170
171 static inline int try_to_freeze(void) { return 0; }
172
173 static inline void freezer_do_not_count(void) {}
174 static inline void freezer_count(void) {}
175 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
176 static inline void set_freezable(void) {}
177
178 #define wait_event_freezable(wq, condition)                             \
179                 wait_event_interruptible(wq, condition)
180
181 #define wait_event_freezable_timeout(wq, condition, timeout)            \
182                 wait_event_interruptible_timeout(wq, condition, timeout)
183
184 #endif /* !CONFIG_PM_SLEEP */
185
186 #endif  /* FREEZER_H_INCLUDED */