Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm
[linux-2.6-microblaze.git] / kernel / freezer.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * kernel/freezer.c - Function to freeze a process
4  *
5  * Originally from kernel/power/process.c
6  */
7
8 #include <linux/interrupt.h>
9 #include <linux/suspend.h>
10 #include <linux/export.h>
11 #include <linux/syscalls.h>
12 #include <linux/freezer.h>
13 #include <linux/kthread.h>
14
15 /* total number of freezing conditions in effect */
16 DEFINE_STATIC_KEY_FALSE(freezer_active);
17 EXPORT_SYMBOL(freezer_active);
18
19 /*
20  * indicate whether PM freezing is in effect, protected by
21  * system_transition_mutex
22  */
23 bool pm_freezing;
24 bool pm_nosig_freezing;
25
26 /* protects freezing and frozen transitions */
27 static DEFINE_SPINLOCK(freezer_lock);
28
29 /**
30  * freezing_slow_path - slow path for testing whether a task needs to be frozen
31  * @p: task to be tested
32  *
33  * This function is called by freezing() if freezer_active isn't zero
34  * and tests whether @p needs to enter and stay in frozen state.  Can be
35  * called under any context.  The freezers are responsible for ensuring the
36  * target tasks see the updated state.
37  */
38 bool freezing_slow_path(struct task_struct *p)
39 {
40         if (p->flags & (PF_NOFREEZE | PF_SUSPEND_TASK))
41                 return false;
42
43         if (test_tsk_thread_flag(p, TIF_MEMDIE))
44                 return false;
45
46         if (pm_nosig_freezing || cgroup_freezing(p))
47                 return true;
48
49         if (pm_freezing && !(p->flags & PF_KTHREAD))
50                 return true;
51
52         return false;
53 }
54 EXPORT_SYMBOL(freezing_slow_path);
55
56 bool frozen(struct task_struct *p)
57 {
58         return READ_ONCE(p->__state) & TASK_FROZEN;
59 }
60
61 /* Refrigerator is place where frozen processes are stored :-). */
62 bool __refrigerator(bool check_kthr_stop)
63 {
64         unsigned int state = get_current_state();
65         bool was_frozen = false;
66
67         pr_debug("%s entered refrigerator\n", current->comm);
68
69         WARN_ON_ONCE(state && !(state & TASK_NORMAL));
70
71         for (;;) {
72                 bool freeze;
73
74                 raw_spin_lock_irq(&current->pi_lock);
75                 set_current_state(TASK_FROZEN);
76                 /* unstale saved_state so that __thaw_task() will wake us up */
77                 current->saved_state = TASK_RUNNING;
78                 raw_spin_unlock_irq(&current->pi_lock);
79
80                 spin_lock_irq(&freezer_lock);
81                 freeze = freezing(current) && !(check_kthr_stop && kthread_should_stop());
82                 spin_unlock_irq(&freezer_lock);
83
84                 if (!freeze)
85                         break;
86
87                 was_frozen = true;
88                 schedule();
89         }
90         __set_current_state(TASK_RUNNING);
91
92         pr_debug("%s left refrigerator\n", current->comm);
93
94         return was_frozen;
95 }
96 EXPORT_SYMBOL(__refrigerator);
97
98 static void fake_signal_wake_up(struct task_struct *p)
99 {
100         unsigned long flags;
101
102         if (lock_task_sighand(p, &flags)) {
103                 signal_wake_up(p, 0);
104                 unlock_task_sighand(p, &flags);
105         }
106 }
107
108 static int __set_task_frozen(struct task_struct *p, void *arg)
109 {
110         unsigned int state = READ_ONCE(p->__state);
111
112         if (p->on_rq)
113                 return 0;
114
115         if (p != current && task_curr(p))
116                 return 0;
117
118         if (!(state & (TASK_FREEZABLE | __TASK_STOPPED | __TASK_TRACED)))
119                 return 0;
120
121         /*
122          * Only TASK_NORMAL can be augmented with TASK_FREEZABLE, since they
123          * can suffer spurious wakeups.
124          */
125         if (state & TASK_FREEZABLE)
126                 WARN_ON_ONCE(!(state & TASK_NORMAL));
127
128 #ifdef CONFIG_LOCKDEP
129         /*
130          * It's dangerous to freeze with locks held; there be dragons there.
131          */
132         if (!(state & __TASK_FREEZABLE_UNSAFE))
133                 WARN_ON_ONCE(debug_locks && p->lockdep_depth);
134 #endif
135
136         p->saved_state = p->__state;
137         WRITE_ONCE(p->__state, TASK_FROZEN);
138         return TASK_FROZEN;
139 }
140
141 static bool __freeze_task(struct task_struct *p)
142 {
143         /* TASK_FREEZABLE|TASK_STOPPED|TASK_TRACED -> TASK_FROZEN */
144         return task_call_func(p, __set_task_frozen, NULL);
145 }
146
147 /**
148  * freeze_task - send a freeze request to given task
149  * @p: task to send the request to
150  *
151  * If @p is freezing, the freeze request is sent either by sending a fake
152  * signal (if it's not a kernel thread) or waking it up (if it's a kernel
153  * thread).
154  *
155  * RETURNS:
156  * %false, if @p is not freezing or already frozen; %true, otherwise
157  */
158 bool freeze_task(struct task_struct *p)
159 {
160         unsigned long flags;
161
162         spin_lock_irqsave(&freezer_lock, flags);
163         if (!freezing(p) || frozen(p) || __freeze_task(p)) {
164                 spin_unlock_irqrestore(&freezer_lock, flags);
165                 return false;
166         }
167
168         if (!(p->flags & PF_KTHREAD))
169                 fake_signal_wake_up(p);
170         else
171                 wake_up_state(p, TASK_NORMAL);
172
173         spin_unlock_irqrestore(&freezer_lock, flags);
174         return true;
175 }
176
177 /*
178  * Restore the saved_state before the task entered freezer. For typical task
179  * in the __refrigerator(), saved_state == TASK_RUNNING so nothing happens
180  * here. For tasks which were TASK_NORMAL | TASK_FREEZABLE, their initial state
181  * is restored unless they got an expected wakeup (see ttwu_state_match()).
182  * Returns 1 if the task state was restored.
183  */
184 static int __restore_freezer_state(struct task_struct *p, void *arg)
185 {
186         unsigned int state = p->saved_state;
187
188         if (state != TASK_RUNNING) {
189                 WRITE_ONCE(p->__state, state);
190                 return 1;
191         }
192
193         return 0;
194 }
195
196 void __thaw_task(struct task_struct *p)
197 {
198         unsigned long flags;
199
200         spin_lock_irqsave(&freezer_lock, flags);
201         if (WARN_ON_ONCE(freezing(p)))
202                 goto unlock;
203
204         if (task_call_func(p, __restore_freezer_state, NULL))
205                 goto unlock;
206
207         wake_up_state(p, TASK_FROZEN);
208 unlock:
209         spin_unlock_irqrestore(&freezer_lock, flags);
210 }
211
212 /**
213  * set_freezable - make %current freezable
214  *
215  * Mark %current freezable and enter refrigerator if necessary.
216  */
217 bool set_freezable(void)
218 {
219         might_sleep();
220
221         /*
222          * Modify flags while holding freezer_lock.  This ensures the
223          * freezer notices that we aren't frozen yet or the freezing
224          * condition is visible to try_to_freeze() below.
225          */
226         spin_lock_irq(&freezer_lock);
227         current->flags &= ~PF_NOFREEZE;
228         spin_unlock_irq(&freezer_lock);
229
230         return try_to_freeze();
231 }
232 EXPORT_SYMBOL(set_freezable);