1 // SPDX-License-Identifier: GPL-2.0-only <<
2 /* 1 /*
3 * kernel/freezer.c - Function to freeze a pro 2 * kernel/freezer.c - Function to freeze a process
4 * 3 *
5 * Originally from kernel/power/process.c 4 * Originally from kernel/power/process.c
6 */ 5 */
7 6
8 #include <linux/interrupt.h> 7 #include <linux/interrupt.h>
9 #include <linux/suspend.h> 8 #include <linux/suspend.h>
10 #include <linux/export.h> 9 #include <linux/export.h>
11 #include <linux/syscalls.h> 10 #include <linux/syscalls.h>
12 #include <linux/freezer.h> 11 #include <linux/freezer.h>
13 #include <linux/kthread.h> 12 #include <linux/kthread.h>
14 13
15 /* total number of freezing conditions in effe 14 /* total number of freezing conditions in effect */
16 DEFINE_STATIC_KEY_FALSE(freezer_active); !! 15 atomic_t system_freezing_cnt = ATOMIC_INIT(0);
17 EXPORT_SYMBOL(freezer_active); !! 16 EXPORT_SYMBOL(system_freezing_cnt);
18 17
19 /* !! 18 /* indicate whether PM freezing is in effect, protected by pm_mutex */
20 * indicate whether PM freezing is in effect, <<
21 * system_transition_mutex <<
22 */ <<
23 bool pm_freezing; 19 bool pm_freezing;
24 bool pm_nosig_freezing; 20 bool pm_nosig_freezing;
25 21
>> 22 /*
>> 23 * Temporary export for the deadlock workaround in ata_scsi_hotplug().
>> 24 * Remove once the hack becomes unnecessary.
>> 25 */
>> 26 EXPORT_SYMBOL_GPL(pm_freezing);
>> 27
26 /* protects freezing and frozen transitions */ 28 /* protects freezing and frozen transitions */
27 static DEFINE_SPINLOCK(freezer_lock); 29 static DEFINE_SPINLOCK(freezer_lock);
28 30
29 /** 31 /**
30 * freezing_slow_path - slow path for testing 32 * freezing_slow_path - slow path for testing whether a task needs to be frozen
31 * @p: task to be tested 33 * @p: task to be tested
32 * 34 *
33 * This function is called by freezing() if fr !! 35 * This function is called by freezing() if system_freezing_cnt isn't zero
34 * and tests whether @p needs to enter and sta 36 * and tests whether @p needs to enter and stay in frozen state. Can be
35 * called under any context. The freezers are 37 * called under any context. The freezers are responsible for ensuring the
36 * target tasks see the updated state. 38 * target tasks see the updated state.
37 */ 39 */
38 bool freezing_slow_path(struct task_struct *p) 40 bool freezing_slow_path(struct task_struct *p)
39 { 41 {
40 if (p->flags & (PF_NOFREEZE | PF_SUSPE 42 if (p->flags & (PF_NOFREEZE | PF_SUSPEND_TASK))
41 return false; 43 return false;
42 44
43 if (test_tsk_thread_flag(p, TIF_MEMDIE 45 if (test_tsk_thread_flag(p, TIF_MEMDIE))
44 return false; 46 return false;
45 47
46 if (pm_nosig_freezing || cgroup_freezi 48 if (pm_nosig_freezing || cgroup_freezing(p))
47 return true; 49 return true;
48 50
49 if (pm_freezing && !(p->flags & PF_KTH 51 if (pm_freezing && !(p->flags & PF_KTHREAD))
50 return true; 52 return true;
51 53
52 return false; 54 return false;
53 } 55 }
54 EXPORT_SYMBOL(freezing_slow_path); 56 EXPORT_SYMBOL(freezing_slow_path);
55 57
56 bool frozen(struct task_struct *p) <<
57 { <<
58 return READ_ONCE(p->__state) & TASK_FR <<
59 } <<
60 <<
61 /* Refrigerator is place where frozen processe 58 /* Refrigerator is place where frozen processes are stored :-). */
62 bool __refrigerator(bool check_kthr_stop) 59 bool __refrigerator(bool check_kthr_stop)
63 { 60 {
64 unsigned int state = get_current_state !! 61 /* Hmm, should we be allowed to suspend when there are realtime
>> 62 processes around? */
65 bool was_frozen = false; 63 bool was_frozen = false;
>> 64 long save = current->state;
66 65
67 pr_debug("%s entered refrigerator\n", 66 pr_debug("%s entered refrigerator\n", current->comm);
68 67
69 WARN_ON_ONCE(state && !(state & TASK_N <<
70 <<
71 for (;;) { 68 for (;;) {
72 bool freeze; !! 69 set_current_state(TASK_UNINTERRUPTIBLE);
73 <<
74 raw_spin_lock_irq(¤t->pi <<
75 WRITE_ONCE(current->__state, T <<
76 /* unstale saved_state so that <<
77 current->saved_state = TASK_RU <<
78 raw_spin_unlock_irq(¤t-> <<
79 70
80 spin_lock_irq(&freezer_lock); 71 spin_lock_irq(&freezer_lock);
81 freeze = freezing(current) && !! 72 current->flags |= PF_FROZEN;
>> 73 if (!freezing(current) ||
>> 74 (check_kthr_stop && kthread_should_stop()))
>> 75 current->flags &= ~PF_FROZEN;
82 spin_unlock_irq(&freezer_lock) 76 spin_unlock_irq(&freezer_lock);
83 77
84 if (!freeze) !! 78 if (!(current->flags & PF_FROZEN))
85 break; 79 break;
86 <<
87 was_frozen = true; 80 was_frozen = true;
88 schedule(); 81 schedule();
89 } 82 }
90 __set_current_state(TASK_RUNNING); <<
91 83
92 pr_debug("%s left refrigerator\n", cur 84 pr_debug("%s left refrigerator\n", current->comm);
93 85
>> 86 /*
>> 87 * Restore saved task state before returning. The mb'd version
>> 88 * needs to be used; otherwise, it might silently break
>> 89 * synchronization which depends on ordered task state change.
>> 90 */
>> 91 set_current_state(save);
>> 92
94 return was_frozen; 93 return was_frozen;
95 } 94 }
96 EXPORT_SYMBOL(__refrigerator); 95 EXPORT_SYMBOL(__refrigerator);
97 96
98 static void fake_signal_wake_up(struct task_st 97 static void fake_signal_wake_up(struct task_struct *p)
99 { 98 {
100 unsigned long flags; 99 unsigned long flags;
101 100
102 if (lock_task_sighand(p, &flags)) { 101 if (lock_task_sighand(p, &flags)) {
103 signal_wake_up(p, 0); 102 signal_wake_up(p, 0);
104 unlock_task_sighand(p, &flags) 103 unlock_task_sighand(p, &flags);
105 } 104 }
106 } 105 }
107 106
108 static int __set_task_frozen(struct task_struc <<
109 { <<
110 unsigned int state = READ_ONCE(p->__st <<
111 <<
112 /* <<
113 * Allow freezing the sched_delayed ta <<
114 * ttwu() fixes them up, so it is safe <<
115 * of waiting for them to get fully de <<
116 */ <<
117 if (task_is_runnable(p)) <<
118 return 0; <<
119 <<
120 if (p != current && task_curr(p)) <<
121 return 0; <<
122 <<
123 if (!(state & (TASK_FREEZABLE | __TASK <<
124 return 0; <<
125 <<
126 /* <<
127 * Only TASK_NORMAL can be augmented w <<
128 * can suffer spurious wakeups. <<
129 */ <<
130 if (state & TASK_FREEZABLE) <<
131 WARN_ON_ONCE(!(state & TASK_NO <<
132 <<
133 #ifdef CONFIG_LOCKDEP <<
134 /* <<
135 * It's dangerous to freeze with locks <<
136 */ <<
137 if (!(state & __TASK_FREEZABLE_UNSAFE) <<
138 WARN_ON_ONCE(debug_locks && p- <<
139 #endif <<
140 <<
141 p->saved_state = p->__state; <<
142 WRITE_ONCE(p->__state, TASK_FROZEN); <<
143 return TASK_FROZEN; <<
144 } <<
145 <<
146 static bool __freeze_task(struct task_struct * <<
147 { <<
148 /* TASK_FREEZABLE|TASK_STOPPED|TASK_TR <<
149 return task_call_func(p, __set_task_fr <<
150 } <<
151 <<
152 /** 107 /**
153 * freeze_task - send a freeze request to give 108 * freeze_task - send a freeze request to given task
154 * @p: task to send the request to 109 * @p: task to send the request to
155 * 110 *
156 * If @p is freezing, the freeze request is se 111 * If @p is freezing, the freeze request is sent either by sending a fake
157 * signal (if it's not a kernel thread) or wak 112 * signal (if it's not a kernel thread) or waking it up (if it's a kernel
158 * thread). 113 * thread).
159 * 114 *
160 * RETURNS: 115 * RETURNS:
161 * %false, if @p is not freezing or already fr 116 * %false, if @p is not freezing or already frozen; %true, otherwise
162 */ 117 */
163 bool freeze_task(struct task_struct *p) 118 bool freeze_task(struct task_struct *p)
164 { 119 {
165 unsigned long flags; 120 unsigned long flags;
166 121
>> 122 /*
>> 123 * This check can race with freezer_do_not_count, but worst case that
>> 124 * will result in an extra wakeup being sent to the task. It does not
>> 125 * race with freezer_count(), the barriers in freezer_count() and
>> 126 * freezer_should_skip() ensure that either freezer_count() sees
>> 127 * freezing == true in try_to_freeze() and freezes, or
>> 128 * freezer_should_skip() sees !PF_FREEZE_SKIP and freezes the task
>> 129 * normally.
>> 130 */
>> 131 if (freezer_should_skip(p))
>> 132 return false;
>> 133
167 spin_lock_irqsave(&freezer_lock, flags 134 spin_lock_irqsave(&freezer_lock, flags);
168 if (!freezing(p) || frozen(p) || __fre !! 135 if (!freezing(p) || frozen(p)) {
169 spin_unlock_irqrestore(&freeze 136 spin_unlock_irqrestore(&freezer_lock, flags);
170 return false; 137 return false;
171 } 138 }
172 139
173 if (!(p->flags & PF_KTHREAD)) 140 if (!(p->flags & PF_KTHREAD))
174 fake_signal_wake_up(p); 141 fake_signal_wake_up(p);
175 else 142 else
176 wake_up_state(p, TASK_NORMAL); !! 143 wake_up_state(p, TASK_INTERRUPTIBLE);
177 144
178 spin_unlock_irqrestore(&freezer_lock, 145 spin_unlock_irqrestore(&freezer_lock, flags);
179 return true; 146 return true;
180 } 147 }
181 148
182 /* <<
183 * Restore the saved_state before the task ent <<
184 * in the __refrigerator(), saved_state == TAS <<
185 * here. For tasks which were TASK_NORMAL | TA <<
186 * is restored unless they got an expected wak <<
187 * Returns 1 if the task state was restored. <<
188 */ <<
189 static int __restore_freezer_state(struct task <<
190 { <<
191 unsigned int state = p->saved_state; <<
192 <<
193 if (state != TASK_RUNNING) { <<
194 WRITE_ONCE(p->__state, state); <<
195 p->saved_state = TASK_RUNNING; <<
196 return 1; <<
197 } <<
198 <<
199 return 0; <<
200 } <<
201 <<
202 void __thaw_task(struct task_struct *p) 149 void __thaw_task(struct task_struct *p)
203 { 150 {
204 unsigned long flags; 151 unsigned long flags;
205 152
206 spin_lock_irqsave(&freezer_lock, flags 153 spin_lock_irqsave(&freezer_lock, flags);
207 if (WARN_ON_ONCE(freezing(p))) !! 154 if (frozen(p))
208 goto unlock; !! 155 wake_up_process(p);
209 <<
210 if (!frozen(p) || task_call_func(p, __ <<
211 goto unlock; <<
212 <<
213 wake_up_state(p, TASK_FROZEN); <<
214 unlock: <<
215 spin_unlock_irqrestore(&freezer_lock, 156 spin_unlock_irqrestore(&freezer_lock, flags);
216 } 157 }
217 158
218 /** 159 /**
219 * set_freezable - make %current freezable 160 * set_freezable - make %current freezable
220 * 161 *
221 * Mark %current freezable and enter refrigera 162 * Mark %current freezable and enter refrigerator if necessary.
222 */ 163 */
223 bool set_freezable(void) 164 bool set_freezable(void)
224 { 165 {
225 might_sleep(); 166 might_sleep();
226 167
227 /* 168 /*
228 * Modify flags while holding freezer_ 169 * Modify flags while holding freezer_lock. This ensures the
229 * freezer notices that we aren't froz 170 * freezer notices that we aren't frozen yet or the freezing
230 * condition is visible to try_to_free 171 * condition is visible to try_to_freeze() below.
231 */ 172 */
232 spin_lock_irq(&freezer_lock); 173 spin_lock_irq(&freezer_lock);
233 current->flags &= ~PF_NOFREEZE; 174 current->flags &= ~PF_NOFREEZE;
234 spin_unlock_irq(&freezer_lock); 175 spin_unlock_irq(&freezer_lock);
235 176
236 return try_to_freeze(); 177 return try_to_freeze();
237 } 178 }
238 EXPORT_SYMBOL(set_freezable); 179 EXPORT_SYMBOL(set_freezable);
239 180
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.