1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * drivers/power/process.c - Functions for starting/stopping processes on 4 * suspend transitions. 5 * 6 * Originally from swsusp. 7 */ 8 9 #include <linux/interrupt.h> 10 #include <linux/oom.h> 11 #include <linux/suspend.h> 12 #include <linux/module.h> 13 #include <linux/sched/debug.h> 14 #include <linux/sched/task.h> 15 #include <linux/syscalls.h> 16 #include <linux/freezer.h> 17 #include <linux/delay.h> 18 #include <linux/workqueue.h> 19 #include <linux/kmod.h> 20 #include <trace/events/power.h> 21 #include <linux/cpuset.h> 22 23 /* 24 * Timeout for stopping processes 25 */ 26 unsigned int __read_mostly freeze_timeout_msecs = 20 * MSEC_PER_SEC; 27 28 static int try_to_freeze_tasks(bool user_only) 29 { 30 const char *what = user_only ? "user space processes" : 31 "remaining freezable tasks"; 32 struct task_struct *g, *p; 33 unsigned long end_time; 34 unsigned int todo; 35 bool wq_busy = false; 36 ktime_t start, end, elapsed; 37 unsigned int elapsed_msecs; 38 bool wakeup = false; 39 int sleep_usecs = USEC_PER_MSEC; 40 41 pr_info("Freezing %s\n", what); 42 43 start = ktime_get_boottime(); 44 45 end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs); 46 47 if (!user_only) 48 freeze_workqueues_begin(); 49 50 while (true) { 51 todo = 0; 52 read_lock(&tasklist_lock); 53 for_each_process_thread(g, p) { 54 if (p == current || !freeze_task(p)) 55 continue; 56 57 todo++; 58 } 59 read_unlock(&tasklist_lock); 60 61 if (!user_only) { 62 wq_busy = freeze_workqueues_busy(); 63 todo += wq_busy; 64 } 65 66 if (!todo || time_after(jiffies, end_time)) 67 break; 68 69 if (pm_wakeup_pending()) { 70 wakeup = true; 71 break; 72 } 73 74 /* 75 * We need to retry, but first give the freezing tasks some 76 * time to enter the refrigerator. Start with an initial 77 * 1 ms sleep followed by exponential backoff until 8 ms. 78 */ 79 usleep_range(sleep_usecs / 2, sleep_usecs); 80 if (sleep_usecs < 8 * USEC_PER_MSEC) 81 sleep_usecs *= 2; 82 } 83 84 end = ktime_get_boottime(); 85 elapsed = ktime_sub(end, start); 86 elapsed_msecs = ktime_to_ms(elapsed); 87 88 if (todo) { 89 pr_err("Freezing %s %s after %d.%03d seconds " 90 "(%d tasks refusing to freeze, wq_busy=%d):\n", what, 91 wakeup ? "aborted" : "failed", 92 elapsed_msecs / 1000, elapsed_msecs % 1000, 93 todo - wq_busy, wq_busy); 94 95 if (wq_busy) 96 show_freezable_workqueues(); 97 98 if (!wakeup || pm_debug_messages_on) { 99 read_lock(&tasklist_lock); 100 for_each_process_thread(g, p) { 101 if (p != current && freezing(p) && !frozen(p)) 102 sched_show_task(p); 103 } 104 read_unlock(&tasklist_lock); 105 } 106 } else { 107 pr_info("Freezing %s completed (elapsed %d.%03d seconds)\n", 108 what, elapsed_msecs / 1000, elapsed_msecs % 1000); 109 } 110 111 return todo ? -EBUSY : 0; 112 } 113 114 /** 115 * freeze_processes - Signal user space processes to enter the refrigerator. 116 * The current thread will not be frozen. The same process that calls 117 * freeze_processes must later call thaw_processes. 118 * 119 * On success, returns 0. On failure, -errno and system is fully thawed. 120 */ 121 int freeze_processes(void) 122 { 123 int error; 124 125 error = __usermodehelper_disable(UMH_FREEZING); 126 if (error) 127 return error; 128 129 /* Make sure this task doesn't get frozen */ 130 current->flags |= PF_SUSPEND_TASK; 131 132 if (!pm_freezing) 133 static_branch_inc(&freezer_active); 134 135 pm_wakeup_clear(0); 136 pm_freezing = true; 137 error = try_to_freeze_tasks(true); 138 if (!error) 139 __usermodehelper_set_disable_depth(UMH_DISABLED); 140 141 BUG_ON(in_atomic()); 142 143 /* 144 * Now that the whole userspace is frozen we need to disable 145 * the OOM killer to disallow any further interference with 146 * killable tasks. There is no guarantee oom victims will 147 * ever reach a point they go away we have to wait with a timeout. 148 */ 149 if (!error && !oom_killer_disable(msecs_to_jiffies(freeze_timeout_msecs))) 150 error = -EBUSY; 151 152 if (error) 153 thaw_processes(); 154 return error; 155 } 156 157 /** 158 * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator. 159 * 160 * On success, returns 0. On failure, -errno and only the kernel threads are 161 * thawed, so as to give a chance to the caller to do additional cleanups 162 * (if any) before thawing the userspace tasks. So, it is the responsibility 163 * of the caller to thaw the userspace tasks, when the time is right. 164 */ 165 int freeze_kernel_threads(void) 166 { 167 int error; 168 169 pm_nosig_freezing = true; 170 error = try_to_freeze_tasks(false); 171 172 BUG_ON(in_atomic()); 173 174 if (error) 175 thaw_kernel_threads(); 176 return error; 177 } 178 179 void thaw_processes(void) 180 { 181 struct task_struct *g, *p; 182 struct task_struct *curr = current; 183 184 trace_suspend_resume(TPS("thaw_processes"), 0, true); 185 if (pm_freezing) 186 static_branch_dec(&freezer_active); 187 pm_freezing = false; 188 pm_nosig_freezing = false; 189 190 oom_killer_enable(); 191 192 pr_info("Restarting tasks ... "); 193 194 __usermodehelper_set_disable_depth(UMH_FREEZING); 195 thaw_workqueues(); 196 197 cpuset_wait_for_hotplug(); 198 199 read_lock(&tasklist_lock); 200 for_each_process_thread(g, p) { 201 /* No other threads should have PF_SUSPEND_TASK set */ 202 WARN_ON((p != curr) && (p->flags & PF_SUSPEND_TASK)); 203 __thaw_task(p); 204 } 205 read_unlock(&tasklist_lock); 206 207 WARN_ON(!(curr->flags & PF_SUSPEND_TASK)); 208 curr->flags &= ~PF_SUSPEND_TASK; 209 210 usermodehelper_enable(); 211 212 schedule(); 213 pr_cont("done.\n"); 214 trace_suspend_resume(TPS("thaw_processes"), 0, false); 215 } 216 217 void thaw_kernel_threads(void) 218 { 219 struct task_struct *g, *p; 220 221 pm_nosig_freezing = false; 222 pr_info("Restarting kernel threads ... "); 223 224 thaw_workqueues(); 225 226 read_lock(&tasklist_lock); 227 for_each_process_thread(g, p) { 228 if (p->flags & PF_KTHREAD) 229 __thaw_task(p); 230 } 231 read_unlock(&tasklist_lock); 232 233 schedule(); 234 pr_cont("done.\n"); 235 } 236