Commit | Line | Data |
---|---|---|
8174f150 MH |
1 | /* |
2 | * kernel/freezer.c - Function to freeze a process | |
3 | * | |
4 | * Originally from kernel/power/process.c | |
5 | */ | |
6 | ||
7 | #include <linux/interrupt.h> | |
8 | #include <linux/suspend.h> | |
9984de1a | 9 | #include <linux/export.h> |
8174f150 MH |
10 | #include <linux/syscalls.h> |
11 | #include <linux/freezer.h> | |
8a32c441 | 12 | #include <linux/kthread.h> |
8174f150 | 13 | |
a3201227 TH |
14 | /* total number of freezing conditions in effect */ |
15 | atomic_t system_freezing_cnt = ATOMIC_INIT(0); | |
16 | EXPORT_SYMBOL(system_freezing_cnt); | |
17 | ||
18 | /* indicate whether PM freezing is in effect, protected by pm_mutex */ | |
19 | bool pm_freezing; | |
20 | bool pm_nosig_freezing; | |
21 | ||
0c9af092 TH |
22 | /* protects freezing and frozen transitions */ |
23 | static DEFINE_SPINLOCK(freezer_lock); | |
8174f150 | 24 | |
a3201227 TH |
25 | /** |
26 | * freezing_slow_path - slow path for testing whether a task needs to be frozen | |
27 | * @p: task to be tested | |
28 | * | |
29 | * This function is called by freezing() if system_freezing_cnt isn't zero | |
30 | * and tests whether @p needs to enter and stay in frozen state. Can be | |
31 | * called under any context. The freezers are responsible for ensuring the | |
32 | * target tasks see the updated state. | |
33 | */ | |
34 | bool freezing_slow_path(struct task_struct *p) | |
35 | { | |
36 | if (p->flags & PF_NOFREEZE) | |
37 | return false; | |
38 | ||
39 | if (pm_nosig_freezing || cgroup_freezing(p)) | |
40 | return true; | |
41 | ||
42 | if (pm_freezing && !(p->flags & PF_FREEZER_NOSIG)) | |
43 | return true; | |
44 | ||
45 | return false; | |
46 | } | |
47 | EXPORT_SYMBOL(freezing_slow_path); | |
48 | ||
8174f150 | 49 | /* Refrigerator is place where frozen processes are stored :-). */ |
8a32c441 | 50 | bool __refrigerator(bool check_kthr_stop) |
8174f150 MH |
51 | { |
52 | /* Hmm, should we be allowed to suspend when there are realtime | |
53 | processes around? */ | |
a0acae0e | 54 | bool was_frozen = false; |
8174f150 MH |
55 | long save; |
56 | ||
6907483b | 57 | /* |
a3201227 TH |
58 | * No point in checking freezing() again - the caller already did. |
59 | * Proceed to enter FROZEN. | |
6907483b | 60 | */ |
0c9af092 | 61 | spin_lock_irq(&freezer_lock); |
6907483b | 62 | repeat: |
6907483b | 63 | current->flags |= PF_FROZEN; |
0c9af092 TH |
64 | spin_unlock_irq(&freezer_lock); |
65 | ||
8174f150 MH |
66 | save = current->state; |
67 | pr_debug("%s entered refrigerator\n", current->comm); | |
68 | ||
69 | spin_lock_irq(¤t->sighand->siglock); | |
70 | recalc_sigpending(); /* We sent fake signal, clean it up */ | |
71 | spin_unlock_irq(¤t->sighand->siglock); | |
72 | ||
73 | for (;;) { | |
74 | set_current_state(TASK_UNINTERRUPTIBLE); | |
6907483b | 75 | if (!freezing(current) || |
8a32c441 | 76 | (check_kthr_stop && kthread_should_stop())) |
8174f150 | 77 | break; |
a0acae0e | 78 | was_frozen = true; |
8174f150 MH |
79 | schedule(); |
80 | } | |
6301cb95 | 81 | |
6907483b TH |
82 | /* leave FROZEN */ |
83 | spin_lock_irq(&freezer_lock); | |
84 | if (freezing(current)) | |
85 | goto repeat; | |
86 | current->flags &= ~PF_FROZEN; | |
87 | spin_unlock_irq(&freezer_lock); | |
88 | ||
8174f150 | 89 | pr_debug("%s left refrigerator\n", current->comm); |
50fb4f7f TH |
90 | |
91 | /* | |
92 | * Restore saved task state before returning. The mb'd version | |
93 | * needs to be used; otherwise, it might silently break | |
94 | * synchronization which depends on ordered task state change. | |
95 | */ | |
96 | set_current_state(save); | |
a0acae0e TH |
97 | |
98 | return was_frozen; | |
8174f150 | 99 | } |
a0acae0e | 100 | EXPORT_SYMBOL(__refrigerator); |
8174f150 MH |
101 | |
102 | static void fake_signal_wake_up(struct task_struct *p) | |
103 | { | |
104 | unsigned long flags; | |
105 | ||
106 | spin_lock_irqsave(&p->sighand->siglock, flags); | |
d6cc7685 | 107 | signal_wake_up(p, 0); |
8174f150 MH |
108 | spin_unlock_irqrestore(&p->sighand->siglock, flags); |
109 | } | |
110 | ||
111 | /** | |
112 | * freeze_task - send a freeze request to given task | |
113 | * @p: task to send the request to | |
114 | * @sig_only: if set, the request will only be sent if the task has the | |
115 | * PF_FREEZER_NOSIG flag unset | |
116 | * Return value: 'false', if @sig_only is set and the task has | |
117 | * PF_FREEZER_NOSIG set or the task is frozen, 'true', otherwise | |
118 | * | |
119 | * The freeze request is sent by setting the tasks's TIF_FREEZE flag and | |
120 | * either sending a fake signal to it or waking it up, depending on whether | |
121 | * or not it has PF_FREEZER_NOSIG set. If @sig_only is set and the task | |
122 | * has PF_FREEZER_NOSIG set (ie. it is a typical kernel thread), its | |
123 | * TIF_FREEZE flag will not be set. | |
124 | */ | |
125 | bool freeze_task(struct task_struct *p, bool sig_only) | |
126 | { | |
0c9af092 | 127 | unsigned long flags; |
0c9af092 TH |
128 | |
129 | spin_lock_irqsave(&freezer_lock, flags); | |
a3201227 TH |
130 | if (!freezing(p) || frozen(p)) { |
131 | spin_unlock_irqrestore(&freezer_lock, flags); | |
132 | return false; | |
133 | } | |
8174f150 | 134 | |
948246f7 | 135 | if (!(p->flags & PF_FREEZER_NOSIG)) { |
8cfe400c TH |
136 | fake_signal_wake_up(p); |
137 | /* | |
138 | * fake_signal_wake_up() goes through p's scheduler | |
139 | * lock and guarantees that TASK_STOPPED/TRACED -> | |
140 | * TASK_RUNNING transition can't race with task state | |
141 | * testing in try_to_freeze_tasks(). | |
142 | */ | |
8174f150 MH |
143 | } else { |
144 | wake_up_state(p, TASK_INTERRUPTIBLE); | |
145 | } | |
a3201227 | 146 | |
0c9af092 | 147 | spin_unlock_irqrestore(&freezer_lock, flags); |
a3201227 | 148 | return true; |
8174f150 MH |
149 | } |
150 | ||
a5be2d0d | 151 | void __thaw_task(struct task_struct *p) |
dc52ddc0 | 152 | { |
0c9af092 | 153 | unsigned long flags; |
a5be2d0d | 154 | |
6907483b TH |
155 | /* |
156 | * Clear freezing and kick @p if FROZEN. Clearing is guaranteed to | |
157 | * be visible to @p as waking up implies wmb. Waking up inside | |
158 | * freezer_lock also prevents wakeups from leaking outside | |
159 | * refrigerator. | |
03afed8b TH |
160 | * |
161 | * If !FROZEN, @p hasn't reached refrigerator, recalc sigpending to | |
162 | * avoid leaving dangling TIF_SIGPENDING behind. | |
6907483b | 163 | */ |
0c9af092 | 164 | spin_lock_irqsave(&freezer_lock, flags); |
03afed8b | 165 | if (frozen(p)) { |
a5be2d0d | 166 | wake_up_process(p); |
03afed8b TH |
167 | } else { |
168 | spin_lock(&p->sighand->siglock); | |
169 | recalc_sigpending_and_wake(p); | |
170 | spin_unlock(&p->sighand->siglock); | |
171 | } | |
0c9af092 | 172 | spin_unlock_irqrestore(&freezer_lock, flags); |
dc52ddc0 | 173 | } |
96ee6d85 TH |
174 | |
175 | /** | |
176 | * __set_freezable - make %current freezable | |
177 | * @with_signal: do we want %TIF_SIGPENDING for notification too? | |
178 | * | |
179 | * Mark %current freezable and enter refrigerator if necessary. | |
180 | */ | |
181 | bool __set_freezable(bool with_signal) | |
182 | { | |
183 | might_sleep(); | |
184 | ||
185 | /* | |
186 | * Modify flags while holding freezer_lock. This ensures the | |
187 | * freezer notices that we aren't frozen yet or the freezing | |
188 | * condition is visible to try_to_freeze() below. | |
189 | */ | |
190 | spin_lock_irq(&freezer_lock); | |
191 | current->flags &= ~PF_NOFREEZE; | |
192 | if (with_signal) | |
193 | current->flags &= ~PF_FREEZER_NOSIG; | |
194 | spin_unlock_irq(&freezer_lock); | |
195 | ||
196 | return try_to_freeze(); | |
197 | } | |
198 | EXPORT_SYMBOL(__set_freezable); |